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 /* Set 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. */
316 ctf_set_base (ctf_file_t
*fp
, const ctf_header_t
*hp
, void *base
)
319 fp
->ctf_buf
= fp
->ctf_base
+ sizeof (ctf_header_t
);
320 fp
->ctf_vars
= (ctf_varent_t
*) ((const char *) fp
->ctf_buf
+
322 fp
->ctf_nvars
= (hp
->cth_typeoff
- hp
->cth_varoff
) / sizeof (ctf_varent_t
);
324 fp
->ctf_str
[CTF_STRTAB_0
].cts_strs
= (const char *) fp
->ctf_buf
326 fp
->ctf_str
[CTF_STRTAB_0
].cts_len
= hp
->cth_strlen
;
328 /* If we have a parent container name and label, store the relocated
329 string pointers in the CTF container for easy access later. */
331 /* Note: before conversion, these will be set to values that will be
332 immediately invalidated by the conversion process, but the conversion
333 process will call ctf_set_base() again to fix things up. */
335 if (hp
->cth_parlabel
!= 0)
336 fp
->ctf_parlabel
= ctf_strptr (fp
, hp
->cth_parlabel
);
337 if (hp
->cth_parname
!= 0)
338 fp
->ctf_parname
= ctf_strptr (fp
, hp
->cth_parname
);
340 ctf_dprintf ("ctf_set_base: parent name %s (label %s)\n",
341 fp
->ctf_parname
? fp
->ctf_parname
: "<NULL>",
342 fp
->ctf_parlabel
? fp
->ctf_parlabel
: "<NULL>");
345 /* Free a ctf_base pointer: the pointer passed, or (if NULL) fp->ctf_base. */
347 ctf_free_base (ctf_file_t
*fp
, unsigned char *ctf_base
)
354 base
= (unsigned char *) fp
->ctf_base
;
356 if (base
!= fp
->ctf_data
.cts_data
&& base
!= NULL
)
360 /* Set the version of the CTF file. */
362 /* When this is reset, LCTF_* changes behaviour, but there is no guarantee that
363 the variable data list associated with each type has been upgraded: the
364 caller must ensure this has been done in advance. */
367 ctf_set_version (ctf_file_t
* fp
, ctf_header_t
* cth
, int ctf_version
)
369 fp
->ctf_version
= ctf_version
;
370 cth
->cth_version
= ctf_version
;
371 fp
->ctf_fileops
= &ctf_fileops
[ctf_version
];
374 /* Upgrade the type table to CTF_VERSION_3 (really CTF_VERSION_1_UPGRADED_3).
376 The upgrade is not done in-place: the ctf_base is moved. ctf_strptr() must
377 not be called before reallocation is complete.
379 Type kinds not checked here due to nonexistence in older formats:
382 upgrade_types (ctf_file_t
*fp
, ctf_header_t
*cth
)
384 const ctf_type_v1_t
*tbuf
;
385 const ctf_type_v1_t
*tend
;
386 unsigned char *ctf_base
, *old_ctf_base
= (unsigned char *) fp
->ctf_base
;
389 ssize_t increase
= 0, size
, increment
, v2increment
, vbytes
, v2bytes
;
390 const ctf_type_v1_t
*tp
;
392 ctf_header_t
*new_cth
;
394 tbuf
= (ctf_type_v1_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
395 tend
= (ctf_type_v1_t
*) (fp
->ctf_buf
+ cth
->cth_stroff
);
397 /* Much like init_types(), this is a two-pass process.
399 First, figure out the new type-section size needed. (It is possible,
400 in theory, for it to be less than the old size, but this is very
401 unlikely. It cannot be so small that cth_typeoff ends up of negative
402 size. We validate this with an assertion below.)
404 We must cater not only for changes in vlen and types sizes but also
405 for changes in 'increment', which happen because v2 places some types
406 into ctf_stype_t where v1 would be forced to use the larger non-stype. */
408 for (tp
= tbuf
; tp
< tend
;
409 tp
= (ctf_type_v1_t
*) ((uintptr_t) tp
+ increment
+ vbytes
))
411 unsigned short kind
= CTF_V1_INFO_KIND (tp
->ctt_info
);
412 unsigned long vlen
= CTF_V1_INFO_VLEN (tp
->ctt_info
);
414 size
= get_ctt_size_v1 (fp
, (const ctf_type_t
*) tp
, NULL
, &increment
);
415 vbytes
= get_vbytes_v1 (kind
, size
, vlen
);
417 get_ctt_size_v2_unconverted (fp
, (const ctf_type_t
*) tp
, NULL
,
419 v2bytes
= get_vbytes_v2 (kind
, size
, vlen
);
421 if ((vbytes
< 0) || (size
< 0))
424 increase
+= v2increment
- increment
; /* May be negative. */
425 increase
+= v2bytes
- vbytes
;
428 /* Allocate enough room for the new buffer, then copy everything but the
429 type section into place, and reset the base accordingly. Leave the
430 version number unchanged, so that LCTF_INFO_* still works on the
431 as-yet-untranslated type info. */
433 if ((ctf_base
= ctf_alloc (fp
->ctf_size
+ increase
)) == NULL
)
436 memcpy (ctf_base
, fp
->ctf_base
, sizeof (ctf_header_t
) + cth
->cth_typeoff
);
437 memcpy (ctf_base
+ sizeof (ctf_header_t
) + cth
->cth_stroff
+ increase
,
438 fp
->ctf_base
+ sizeof (ctf_header_t
) + cth
->cth_stroff
,
441 memset (ctf_base
+ sizeof (ctf_header_t
) + cth
->cth_typeoff
, 0,
442 cth
->cth_stroff
- cth
->cth_typeoff
+ increase
);
444 /* The cth here is an automatic variable in ctf_bufopen(), and transient
445 (a copy maintained because at that stage the header read out of the
446 ctf file may be read-only). We make all modifications in the
447 canonical copy at ctf_base (by now, writable), then copy it back into
450 new_cth
= (ctf_header_t
*) ctf_base
;
451 new_cth
->cth_stroff
+= increase
;
452 fp
->ctf_size
+= increase
;
453 assert (new_cth
->cth_stroff
>= new_cth
->cth_typeoff
);
454 ctf_set_base (fp
, new_cth
, ctf_base
);
456 t2buf
= (ctf_type_t
*) (fp
->ctf_buf
+ new_cth
->cth_typeoff
);
458 /* Iterate through all the types again, upgrading them.
460 Everything that hasn't changed can just be outright memcpy()ed.
461 Things that have changed need field-by-field consideration. */
463 for (tp
= tbuf
, t2p
= t2buf
; tp
< tend
;
464 tp
= (ctf_type_v1_t
*) ((uintptr_t) tp
+ increment
+ vbytes
),
465 t2p
= (ctf_type_t
*) ((uintptr_t) t2p
+ v2increment
+ v2bytes
))
467 unsigned short kind
= CTF_V1_INFO_KIND (tp
->ctt_info
);
468 int isroot
= CTF_V1_INFO_ISROOT (tp
->ctt_info
);
469 unsigned long vlen
= CTF_V1_INFO_VLEN (tp
->ctt_info
);
471 void *vdata
, *v2data
;
473 size
= get_ctt_size_v1 (fp
, (const ctf_type_t
*) tp
, NULL
, &increment
);
474 vbytes
= get_vbytes_v1 (kind
, size
, vlen
);
476 t2p
->ctt_name
= tp
->ctt_name
;
477 t2p
->ctt_info
= CTF_TYPE_INFO (kind
, isroot
, vlen
);
488 t2p
->ctt_type
= tp
->ctt_type
;
497 if ((size_t) size
<= CTF_MAX_SIZE
)
498 t2p
->ctt_size
= size
;
501 t2p
->ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
502 t2p
->ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
507 v2size
= get_ctt_size_v2 (fp
, t2p
, NULL
, &v2increment
);
508 v2bytes
= get_vbytes_v2 (kind
, v2size
, vlen
);
510 /* Catch out-of-sync get_ctt_size_*(). The count goes wrong if
511 these are not identical (and having them different makes no
512 sense semantically). */
514 assert (size
== v2size
);
516 /* Now the varlen info. */
518 vdata
= (void *) ((uintptr_t) tp
+ increment
);
519 v2data
= (void *) ((uintptr_t) t2p
+ v2increment
);
525 const ctf_array_v1_t
*ap
= (const ctf_array_v1_t
*) vdata
;
526 ctf_array_t
*a2p
= (ctf_array_t
*) v2data
;
528 a2p
->cta_contents
= ap
->cta_contents
;
529 a2p
->cta_index
= ap
->cta_index
;
530 a2p
->cta_nelems
= ap
->cta_nelems
;
537 const ctf_member_v1_t
*m1
= (const ctf_member_v1_t
*) vdata
;
538 const ctf_lmember_v1_t
*lm1
= (const ctf_lmember_v1_t
*) m1
;
539 ctf_member_t
*m2
= (ctf_member_t
*) v2data
;
540 ctf_lmember_t
*lm2
= (ctf_lmember_t
*) m2
;
543 /* We walk all four pointers forward, but only reference the two
544 that are valid for the given size, to avoid quadruplicating all
547 for (i
= vlen
; i
!= 0; i
--, m1
++, lm1
++, m2
++, lm2
++)
550 if (size
< CTF_LSTRUCT_THRESH_V1
)
552 offset
= m1
->ctm_offset
;
553 tmp
.ctm_name
= m1
->ctm_name
;
554 tmp
.ctm_type
= m1
->ctm_type
;
558 offset
= CTF_LMEM_OFFSET (lm1
);
559 tmp
.ctm_name
= lm1
->ctlm_name
;
560 tmp
.ctm_type
= lm1
->ctlm_type
;
562 if (size
< CTF_LSTRUCT_THRESH
)
564 m2
->ctm_name
= tmp
.ctm_name
;
565 m2
->ctm_type
= tmp
.ctm_type
;
566 m2
->ctm_offset
= offset
;
570 lm2
->ctlm_name
= tmp
.ctm_name
;
571 lm2
->ctlm_type
= tmp
.ctm_type
;
572 lm2
->ctlm_offsethi
= CTF_OFFSET_TO_LMEMHI (offset
);
573 lm2
->ctlm_offsetlo
= CTF_OFFSET_TO_LMEMLO (offset
);
581 unsigned short *a1
= (unsigned short *) vdata
;
582 uint32_t *a2
= (uint32_t *) v2data
;
584 for (i
= vlen
; i
!= 0; i
--, a1
++, a2
++)
589 /* Catch out-of-sync get_vbytes_*(). */
590 assert (vbytes
== v2bytes
);
591 memcpy (v2data
, vdata
, vbytes
);
595 /* Verify that the entire region was converted. If not, we are either
596 converting too much, or too little (leading to a buffer overrun either here
597 or at read time, in init_types().) */
599 assert ((size_t) t2p
- (size_t) fp
->ctf_buf
== new_cth
->cth_stroff
);
601 ctf_set_version (fp
, (ctf_header_t
*) ctf_base
, CTF_VERSION_1_UPGRADED_3
);
602 ctf_free_base (fp
, old_ctf_base
);
603 memcpy (cth
, new_cth
, sizeof (ctf_header_t
));
608 /* Initialize the type ID translation table with the byte offset of each type,
609 and initialize the hash tables of each named type. Upgrade the type table to
610 the latest supported representation in the process, if needed, and if this
611 recension of libctf supports upgrading. */
614 init_types (ctf_file_t
*fp
, ctf_header_t
*cth
)
616 const ctf_type_t
*tbuf
;
617 const ctf_type_t
*tend
;
619 unsigned long pop
[CTF_K_MAX
+ 1] = { 0 };
620 const ctf_type_t
*tp
;
625 /* We determine whether the container is a child or a parent based on
626 the value of cth_parname. */
628 int child
= cth
->cth_parname
!= 0;
629 int nlstructs
= 0, nlunions
= 0;
632 if (_libctf_unlikely_ (fp
->ctf_version
== CTF_VERSION_1
))
635 if ((err
= upgrade_types (fp
, cth
)) != 0)
636 return err
; /* Upgrade failed. */
639 tbuf
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
640 tend
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_stroff
);
642 /* We make two passes through the entire type section. In this first
643 pass, we count the number of each type and the total number of types. */
645 for (tp
= tbuf
; tp
< tend
; fp
->ctf_typemax
++)
647 unsigned short kind
= LCTF_INFO_KIND (fp
, tp
->ctt_info
);
648 unsigned long vlen
= LCTF_INFO_VLEN (fp
, tp
->ctt_info
);
649 ssize_t size
, increment
, vbytes
;
651 (void) ctf_get_ctt_size (fp
, tp
, &size
, &increment
);
652 vbytes
= LCTF_VBYTES (fp
, kind
, size
, vlen
);
657 if (kind
== CTF_K_FORWARD
)
659 /* For forward declarations, ctt_type is the CTF_K_* kind for the tag,
660 so bump that population count too. If ctt_type is unknown, treat
661 the tag as a struct. */
663 if (tp
->ctt_type
== CTF_K_UNKNOWN
|| tp
->ctt_type
>= CTF_K_MAX
)
668 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
674 ctf_dprintf ("CTF container %p is a child\n", (void *) fp
);
675 fp
->ctf_flags
|= LCTF_CHILD
;
678 ctf_dprintf ("CTF container %p is a parent\n", (void *) fp
);
680 /* Now that we've counted up the number of each type, we can allocate
681 the hash tables, type translation table, and pointer table. */
683 if ((fp
->ctf_structs
= ctf_hash_create (pop
[CTF_K_STRUCT
], ctf_hash_string
,
684 ctf_hash_eq_string
)) == NULL
)
687 if ((fp
->ctf_unions
= ctf_hash_create (pop
[CTF_K_UNION
], ctf_hash_string
,
688 ctf_hash_eq_string
)) == NULL
)
691 if ((fp
->ctf_enums
= ctf_hash_create (pop
[CTF_K_ENUM
], ctf_hash_string
,
692 ctf_hash_eq_string
)) == NULL
)
695 if ((fp
->ctf_names
= ctf_hash_create (pop
[CTF_K_INTEGER
] +
697 pop
[CTF_K_FUNCTION
] +
700 pop
[CTF_K_VOLATILE
] +
704 ctf_hash_eq_string
)) == NULL
)
707 fp
->ctf_txlate
= ctf_alloc (sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
708 fp
->ctf_ptrtab
= ctf_alloc (sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
710 if (fp
->ctf_txlate
== NULL
|| fp
->ctf_ptrtab
== NULL
)
711 return ENOMEM
; /* Memory allocation failed. */
714 *xp
++ = 0; /* Type id 0 is used as a sentinel value. */
716 memset (fp
->ctf_txlate
, 0, sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
717 memset (fp
->ctf_ptrtab
, 0, sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
719 /* In the second pass through the types, we fill in each entry of the
720 type and pointer tables and add names to the appropriate hashes. */
722 for (id
= 1, tp
= tbuf
; tp
< tend
; xp
++, id
++)
724 unsigned short kind
= LCTF_INFO_KIND (fp
, tp
->ctt_info
);
725 unsigned short flag
= LCTF_INFO_ISROOT (fp
, tp
->ctt_info
);
726 unsigned long vlen
= LCTF_INFO_VLEN (fp
, tp
->ctt_info
);
727 ssize_t size
, increment
, vbytes
;
731 (void) ctf_get_ctt_size (fp
, tp
, &size
, &increment
);
732 name
= ctf_strptr (fp
, tp
->ctt_name
);
733 vbytes
= LCTF_VBYTES (fp
, kind
, size
, vlen
);
739 /* Names are reused by bit-fields, which are differentiated by their
740 encodings, and so typically we'd record only the first instance of
741 a given intrinsic. However, we replace an existing type with a
742 root-visible version so that we can be sure to find it when
743 checking for conflicting definitions in ctf_add_type(). */
745 if (((ctf_hash_lookup_type (fp
->ctf_names
, fp
, name
)) == 0)
746 || (flag
& CTF_ADD_ROOT
))
748 err
= ctf_hash_define_type (fp
->ctf_names
, fp
,
749 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
751 if (err
!= 0 && err
!= ECTF_STRTAB
)
756 /* These kinds have no name, so do not need interning into any
763 err
= ctf_hash_insert_type (fp
->ctf_names
, fp
,
764 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
766 if (err
!= 0 && err
!= ECTF_STRTAB
)
771 err
= ctf_hash_define_type (fp
->ctf_structs
, fp
,
772 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
775 if (err
!= 0 && err
!= ECTF_STRTAB
)
778 if (size
>= CTF_LSTRUCT_THRESH
)
783 err
= ctf_hash_define_type (fp
->ctf_unions
, fp
,
784 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
787 if (err
!= 0 && err
!= ECTF_STRTAB
)
790 if (size
>= CTF_LSTRUCT_THRESH
)
795 err
= ctf_hash_define_type (fp
->ctf_enums
, fp
,
796 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
799 if (err
!= 0 && err
!= ECTF_STRTAB
)
804 err
= ctf_hash_insert_type (fp
->ctf_names
, fp
,
805 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
807 if (err
!= 0 && err
!= ECTF_STRTAB
)
812 /* Only insert forward tags into the given hash if the type or tag
813 name is not already present. */
814 switch (tp
->ctt_type
)
817 hp
= fp
->ctf_structs
;
826 hp
= fp
->ctf_structs
;
829 if (ctf_hash_lookup_type (hp
, fp
, name
) == 0)
831 err
= ctf_hash_insert_type (hp
, fp
,
832 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
834 if (err
!= 0 && err
!= ECTF_STRTAB
)
840 /* If the type referenced by the pointer is in this CTF container,
841 then store the index of the pointer type in
842 fp->ctf_ptrtab[ index of referenced type ]. */
844 if (LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
845 && LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
846 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = id
;
852 err
= ctf_hash_insert_type (fp
->ctf_names
, fp
,
853 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
855 if (err
!= 0 && err
!= ECTF_STRTAB
)
859 ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
864 *xp
= (uint32_t) ((uintptr_t) tp
- (uintptr_t) fp
->ctf_buf
);
865 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
868 ctf_dprintf ("%lu total types processed\n", fp
->ctf_typemax
);
869 ctf_dprintf ("%u enum names hashed\n", ctf_hash_size (fp
->ctf_enums
));
870 ctf_dprintf ("%u struct names hashed (%d long)\n",
871 ctf_hash_size (fp
->ctf_structs
), nlstructs
);
872 ctf_dprintf ("%u union names hashed (%d long)\n",
873 ctf_hash_size (fp
->ctf_unions
), nlunions
);
874 ctf_dprintf ("%u base type names hashed\n", ctf_hash_size (fp
->ctf_names
));
876 /* Make an additional pass through the pointer table to find pointers that
877 point to anonymous typedef nodes. If we find one, modify the pointer table
878 so that the pointer is also known to point to the node that is referenced
879 by the anonymous typedef node. */
881 for (id
= 1; id
<= fp
->ctf_typemax
; id
++)
883 if ((dst
= fp
->ctf_ptrtab
[id
]) != 0)
885 tp
= LCTF_INDEX_TO_TYPEPTR (fp
, id
);
887 if (LCTF_INFO_KIND (fp
, tp
->ctt_info
) == CTF_K_TYPEDEF
&&
888 strcmp (ctf_strptr (fp
, tp
->ctt_name
), "") == 0 &&
889 LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
&&
890 LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
891 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = dst
;
898 /* Endianness-flipping routines.
900 We flip everything, mindlessly, even 1-byte entities, so that future
901 expansions do not require changes to this code. */
903 /* < C11? define away static assertions. */
905 #if !defined (__STDC_VERSION__) || __STDC_VERSION__ < 201112L
906 #define _Static_assert(cond, err)
909 /* Swap the endianness of something. */
911 #define swap_thing(x) \
913 _Static_assert (sizeof (x) == 1 || (sizeof (x) % 2 == 0 \
914 && sizeof (x) <= 8), \
915 "Invalid size, update endianness code"); \
916 switch (sizeof (x)) { \
917 case 2: x = bswap_16 (x); break; \
918 case 4: x = bswap_32 (x); break; \
919 case 8: x = bswap_64 (x); break; \
920 case 1: /* Nothing needs doing */ \
925 /* Flip the endianness of the CTF header. */
928 flip_header (ctf_header_t
*cth
)
930 swap_thing (cth
->cth_preamble
.ctp_magic
);
931 swap_thing (cth
->cth_preamble
.ctp_version
);
932 swap_thing (cth
->cth_preamble
.ctp_flags
);
933 swap_thing (cth
->cth_parlabel
);
934 swap_thing (cth
->cth_parname
);
935 swap_thing (cth
->cth_objtoff
);
936 swap_thing (cth
->cth_funcoff
);
937 swap_thing (cth
->cth_varoff
);
938 swap_thing (cth
->cth_typeoff
);
939 swap_thing (cth
->cth_stroff
);
940 swap_thing (cth
->cth_strlen
);
943 /* Flip the endianness of the label section, an array of ctf_lblent_t. */
946 flip_lbls (void *start
, size_t len
)
948 ctf_lblent_t
*lbl
= start
;
950 for (ssize_t i
= len
/ sizeof (struct ctf_lblent
); i
> 0; lbl
++, i
--)
952 swap_thing (lbl
->ctl_label
);
953 swap_thing (lbl
->ctl_type
);
957 /* Flip the endianness of the data-object or function sections, an array of
958 uint32_t. (The function section has more internal structure, but that
959 structure is an array of uint32_t, so can be treated as one big array for
963 flip_objts (void *start
, size_t len
)
965 uint32_t *obj
= start
;
967 for (ssize_t i
= len
/ sizeof (uint32_t); i
> 0; obj
++, i
--)
971 /* Flip the endianness of the variable section, an array of ctf_varent_t. */
974 flip_vars (void *start
, size_t len
)
976 ctf_varent_t
*var
= start
;
978 for (ssize_t i
= len
/ sizeof (struct ctf_varent
); i
> 0; var
++, i
--)
980 swap_thing (var
->ctv_name
);
981 swap_thing (var
->ctv_type
);
985 /* Flip the endianness of the type section, a tagged array of ctf_type or
986 ctf_stype followed by variable data. */
989 flip_types (void *start
, size_t len
)
991 ctf_type_t
*t
= start
;
993 while ((uintptr_t) t
< ((uintptr_t) start
) + len
)
995 swap_thing (t
->ctt_name
);
996 swap_thing (t
->ctt_info
);
997 swap_thing (t
->ctt_size
);
999 uint32_t kind
= CTF_V2_INFO_KIND (t
->ctt_info
);
1000 size_t size
= t
->ctt_size
;
1001 uint32_t vlen
= CTF_V2_INFO_VLEN (t
->ctt_info
);
1002 size_t vbytes
= get_vbytes_v2 (kind
, size
, vlen
);
1004 if (_libctf_unlikely_ (size
== CTF_LSIZE_SENT
))
1006 swap_thing (t
->ctt_lsizehi
);
1007 swap_thing (t
->ctt_lsizelo
);
1008 size
= CTF_TYPE_LSIZE (t
);
1009 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_type_t
));
1012 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_stype_t
));
1020 case CTF_K_VOLATILE
:
1022 case CTF_K_RESTRICT
:
1023 /* These types have no vlen data to swap. */
1024 assert (vbytes
== 0);
1030 /* These types have a single uint32_t. */
1032 uint32_t *item
= (uint32_t *) t
;
1038 case CTF_K_FUNCTION
:
1040 /* This type has a bunch of uint32_ts. */
1042 uint32_t *item
= (uint32_t *) t
;
1044 for (ssize_t i
= vlen
; i
> 0; item
++, i
--)
1051 /* This has a single ctf_array_t. */
1053 ctf_array_t
*a
= (ctf_array_t
*) t
;
1055 assert (vbytes
== sizeof (ctf_array_t
));
1056 swap_thing (a
->cta_contents
);
1057 swap_thing (a
->cta_index
);
1058 swap_thing (a
->cta_nelems
);
1065 /* This has a single ctf_slice_t. */
1067 ctf_slice_t
*s
= (ctf_slice_t
*) t
;
1069 assert (vbytes
== sizeof (ctf_slice_t
));
1070 swap_thing (s
->cts_type
);
1071 swap_thing (s
->cts_offset
);
1072 swap_thing (s
->cts_bits
);
1080 /* This has an array of ctf_member or ctf_lmember, depending on
1081 size. We could consider it to be a simple array of uint32_t,
1082 but for safety's sake in case these structures ever acquire
1083 non-uint32_t members, do it member by member. */
1085 if (_libctf_unlikely_ (size
>= CTF_LSTRUCT_THRESH
))
1087 ctf_lmember_t
*lm
= (ctf_lmember_t
*) t
;
1088 for (ssize_t i
= vlen
; i
> 0; i
--, lm
++)
1090 swap_thing (lm
->ctlm_name
);
1091 swap_thing (lm
->ctlm_offsethi
);
1092 swap_thing (lm
->ctlm_type
);
1093 swap_thing (lm
->ctlm_offsetlo
);
1098 ctf_member_t
*m
= (ctf_member_t
*) t
;
1099 for (ssize_t i
= vlen
; i
> 0; i
--, m
++)
1101 swap_thing (m
->ctm_name
);
1102 swap_thing (m
->ctm_offset
);
1103 swap_thing (m
->ctm_type
);
1111 /* This has an array of ctf_enum_t. */
1113 ctf_enum_t
*item
= (ctf_enum_t
*) t
;
1115 for (ssize_t i
= vlen
; i
> 0; item
++, i
--)
1117 swap_thing (item
->cte_name
);
1118 swap_thing (item
->cte_value
);
1123 ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
1125 return ECTF_CORRUPT
;
1128 t
= (ctf_type_t
*) ((uintptr_t) t
+ vbytes
);
1134 /* Flip the endianness of BASE, given the offsets in the (already endian-
1137 All of this stuff happens before the header is fully initialized, so the
1138 LCTF_*() macros cannot be used yet. Since we do not try to endian-convert v1
1139 data, this is no real loss. */
1142 flip_ctf (ctf_header_t
*cth
, unsigned char *base
)
1144 base
+= sizeof (ctf_header_t
);
1146 flip_lbls (base
+ cth
->cth_lbloff
, cth
->cth_objtoff
- cth
->cth_lbloff
);
1147 flip_objts (base
+ cth
->cth_objtoff
, cth
->cth_funcoff
- cth
->cth_objtoff
);
1148 flip_objts (base
+ cth
->cth_funcoff
, cth
->cth_varoff
- cth
->cth_funcoff
);
1149 flip_vars (base
+ cth
->cth_varoff
, cth
->cth_typeoff
- cth
->cth_varoff
);
1150 return flip_types (base
+ cth
->cth_typeoff
, cth
->cth_stroff
- cth
->cth_typeoff
);
1153 /* Open a CTF file, mocking up a suitable ctf_sect. */
1154 ctf_file_t
*ctf_simple_open (const char *ctfsect
, size_t ctfsect_size
,
1155 const char *symsect
, size_t symsect_size
,
1156 size_t symsect_entsize
,
1157 const char *strsect
, size_t strsect_size
,
1160 ctf_sect_t skeleton
;
1162 ctf_sect_t ctf_sect
, sym_sect
, str_sect
;
1163 ctf_sect_t
*ctfsectp
= NULL
;
1164 ctf_sect_t
*symsectp
= NULL
;
1165 ctf_sect_t
*strsectp
= NULL
;
1167 skeleton
.cts_name
= _CTF_SECTION
;
1168 skeleton
.cts_entsize
= 1;
1172 memcpy (&ctf_sect
, &skeleton
, sizeof (struct ctf_sect
));
1173 ctf_sect
.cts_data
= ctfsect
;
1174 ctf_sect
.cts_size
= ctfsect_size
;
1175 ctfsectp
= &ctf_sect
;
1180 memcpy (&sym_sect
, &skeleton
, sizeof (struct ctf_sect
));
1181 sym_sect
.cts_data
= symsect
;
1182 sym_sect
.cts_size
= symsect_size
;
1183 sym_sect
.cts_entsize
= symsect_entsize
;
1184 symsectp
= &sym_sect
;
1189 memcpy (&str_sect
, &skeleton
, sizeof (struct ctf_sect
));
1190 str_sect
.cts_data
= strsect
;
1191 str_sect
.cts_size
= strsect_size
;
1192 strsectp
= &str_sect
;
1195 return ctf_bufopen (ctfsectp
, symsectp
, strsectp
, errp
);
1198 /* Decode the specified CTF buffer and optional symbol table, and create a new
1199 CTF container representing the symbolic debugging information. This code can
1200 be used directly by the debugger, or it can be used as the engine for
1201 ctf_fdopen() or ctf_open(), below. */
1204 ctf_bufopen (const ctf_sect_t
*ctfsect
, const ctf_sect_t
*symsect
,
1205 const ctf_sect_t
*strsect
, int *errp
)
1207 const ctf_preamble_t
*pp
;
1212 int foreign_endian
= 0;
1215 libctf_init_debug();
1217 if (ctfsect
== NULL
|| ((symsect
== NULL
) != (strsect
== NULL
)))
1218 return (ctf_set_open_errno (errp
, EINVAL
));
1220 if (symsect
!= NULL
&& symsect
->cts_entsize
!= sizeof (Elf32_Sym
) &&
1221 symsect
->cts_entsize
!= sizeof (Elf64_Sym
))
1222 return (ctf_set_open_errno (errp
, ECTF_SYMTAB
));
1224 if (symsect
!= NULL
&& symsect
->cts_data
== NULL
)
1225 return (ctf_set_open_errno (errp
, ECTF_SYMBAD
));
1227 if (strsect
!= NULL
&& strsect
->cts_data
== NULL
)
1228 return (ctf_set_open_errno (errp
, ECTF_STRBAD
));
1230 if (ctfsect
->cts_size
< sizeof (ctf_preamble_t
))
1231 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1233 pp
= (const ctf_preamble_t
*) ctfsect
->cts_data
;
1235 ctf_dprintf ("ctf_bufopen: magic=0x%x version=%u\n",
1236 pp
->ctp_magic
, pp
->ctp_version
);
1238 /* Validate each part of the CTF header.
1240 First, we validate the preamble (common to all versions). At that point,
1241 we know the endianness and specific header version, and can validate the
1242 version-specific parts including section offsets and alignments.
1244 We specifically do not support foreign-endian old versions. */
1246 if (_libctf_unlikely_ (pp
->ctp_magic
!= CTF_MAGIC
))
1248 if (pp
->ctp_magic
== bswap_16 (CTF_MAGIC
))
1250 if (pp
->ctp_version
!= CTF_VERSION_3
)
1251 return (ctf_set_open_errno (errp
, ECTF_CTFVERS
));
1255 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1258 if (_libctf_unlikely_ ((pp
->ctp_version
< CTF_VERSION_1
)
1259 || (pp
->ctp_version
> CTF_VERSION_3
)))
1260 return (ctf_set_open_errno (errp
, ECTF_CTFVERS
));
1262 if ((symsect
!= NULL
) && (pp
->ctp_version
< CTF_VERSION_2
))
1264 /* The symtab can contain function entries which contain embedded ctf
1265 info. We do not support dynamically upgrading such entries (none
1266 should exist in any case, since dwarf2ctf does not create them). */
1268 ctf_dprintf ("ctf_bufopen: CTF version %d symsect not "
1269 "supported\n", pp
->ctp_version
);
1270 return (ctf_set_open_errno (errp
, ECTF_NOTSUP
));
1273 if (ctfsect
->cts_size
< sizeof (ctf_header_t
))
1274 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1276 memcpy (&hp
, ctfsect
->cts_data
, sizeof (hp
));
1281 ctf_dprintf ("header offsets: %x/%x/%x/%x/%x/%x/%x\n",
1282 hp
.cth_lbloff
, hp
.cth_objtoff
, hp
.cth_funcoff
, hp
.cth_varoff
,
1283 hp
.cth_typeoff
, hp
.cth_stroff
, hp
.cth_strlen
);
1284 hdrsz
= sizeof (ctf_header_t
);
1286 size
= hp
.cth_stroff
+ hp
.cth_strlen
;
1288 ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n", (unsigned long) size
);
1290 if (hp
.cth_lbloff
> size
|| hp
.cth_objtoff
> size
1291 || hp
.cth_funcoff
> size
|| hp
.cth_typeoff
> size
|| hp
.cth_stroff
> size
)
1292 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1294 if (hp
.cth_lbloff
> hp
.cth_objtoff
1295 || hp
.cth_objtoff
> hp
.cth_funcoff
1296 || hp
.cth_funcoff
> hp
.cth_typeoff
1297 || hp
.cth_funcoff
> hp
.cth_varoff
1298 || hp
.cth_varoff
> hp
.cth_typeoff
|| hp
.cth_typeoff
> hp
.cth_stroff
)
1299 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1301 if ((hp
.cth_lbloff
& 3) || (hp
.cth_objtoff
& 1)
1302 || (hp
.cth_funcoff
& 1) || (hp
.cth_varoff
& 3) || (hp
.cth_typeoff
& 3))
1303 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1305 /* Once everything is determined to be valid, attempt to decompress the CTF
1306 data buffer if it is compressed, or copy it into new storage if it is not
1307 compressed but needs endian-flipping. Otherwise we just put the data
1308 section's buffer pointer into ctf_buf, below. */
1310 /* Note: if this is a v1 buffer, it will be reallocated and expanded by
1313 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
));
1352 memcpy (base
, ctfsect
->cts_data
, size
+ hdrsz
);
1355 base
= (void *) ctfsect
->cts_data
;
1357 /* Flip the endianness of the copy of the header in the section, to avoid
1358 ending up with a partially-endian-flipped file. */
1361 flip_header ((ctf_header_t
*) base
);
1363 /* Once we have uncompressed and validated the CTF data buffer, we can
1364 proceed with allocating a ctf_file_t and initializing it.
1366 Nothing that depends on buf or base should be set directly in this function
1367 before the init_types() call, because it may be reallocated during
1368 transparent upgrade if this recension of libctf is so configured: see
1369 ctf_set_base() and ctf_realloc_base(). */
1371 if ((fp
= ctf_alloc (sizeof (ctf_file_t
))) == NULL
)
1372 return (ctf_set_open_errno (errp
, ENOMEM
));
1374 memset (fp
, 0, sizeof (ctf_file_t
));
1375 ctf_set_version (fp
, &hp
, hp
.cth_version
);
1377 if (_libctf_unlikely_ (hp
.cth_version
< CTF_VERSION_2
))
1378 fp
->ctf_parmax
= CTF_MAX_PTYPE_V1
;
1380 fp
->ctf_parmax
= CTF_MAX_PTYPE
;
1382 memcpy (&fp
->ctf_data
, ctfsect
, sizeof (ctf_sect_t
));
1384 if (symsect
!= NULL
)
1386 memcpy (&fp
->ctf_symtab
, symsect
, sizeof (ctf_sect_t
));
1387 memcpy (&fp
->ctf_strtab
, strsect
, sizeof (ctf_sect_t
));
1390 if (fp
->ctf_data
.cts_name
!= NULL
)
1391 fp
->ctf_data
.cts_name
= ctf_strdup (fp
->ctf_data
.cts_name
);
1392 if (fp
->ctf_symtab
.cts_name
!= NULL
)
1393 fp
->ctf_symtab
.cts_name
= ctf_strdup (fp
->ctf_symtab
.cts_name
);
1394 if (fp
->ctf_strtab
.cts_name
!= NULL
)
1395 fp
->ctf_strtab
.cts_name
= ctf_strdup (fp
->ctf_strtab
.cts_name
);
1397 if (fp
->ctf_data
.cts_name
== NULL
)
1398 fp
->ctf_data
.cts_name
= _CTF_NULLSTR
;
1399 if (fp
->ctf_symtab
.cts_name
== NULL
)
1400 fp
->ctf_symtab
.cts_name
= _CTF_NULLSTR
;
1401 if (fp
->ctf_strtab
.cts_name
== NULL
)
1402 fp
->ctf_strtab
.cts_name
= _CTF_NULLSTR
;
1404 if (strsect
!= NULL
)
1406 fp
->ctf_str
[CTF_STRTAB_1
].cts_strs
= strsect
->cts_data
;
1407 fp
->ctf_str
[CTF_STRTAB_1
].cts_len
= strsect
->cts_size
;
1410 if (foreign_endian
&&
1411 (err
= flip_ctf (&hp
, base
)) != 0)
1413 /* We can be certain that flip_ctf() will have endian-flipped everything
1414 other than the types table when we return. In particular the header
1415 is fine, so set it, to allow freeing to use the usual code path. */
1417 (void) ctf_set_open_errno (errp
, err
);
1418 ctf_set_base (fp
, &hp
, base
);
1422 ctf_set_base (fp
, &hp
, base
);
1423 fp
->ctf_size
= size
+ hdrsz
;
1425 if ((err
= init_types (fp
, &hp
)) != 0)
1427 (void) ctf_set_open_errno (errp
, err
);
1431 /* If we have a symbol table section, allocate and initialize
1432 the symtab translation table, pointed to by ctf_sxlate. */
1434 if (symsect
!= NULL
)
1436 fp
->ctf_nsyms
= symsect
->cts_size
/ symsect
->cts_entsize
;
1437 fp
->ctf_sxlate
= ctf_alloc (fp
->ctf_nsyms
* sizeof (uint32_t));
1439 if (fp
->ctf_sxlate
== NULL
)
1441 (void) ctf_set_open_errno (errp
, ENOMEM
);
1445 if ((err
= init_symtab (fp
, &hp
, symsect
, strsect
)) != 0)
1447 (void) ctf_set_open_errno (errp
, err
);
1452 /* Initialize the ctf_lookup_by_name top-level dictionary. We keep an
1453 array of type name prefixes and the corresponding ctf_hash to use.
1454 NOTE: This code must be kept in sync with the code in ctf_update(). */
1455 fp
->ctf_lookups
[0].ctl_prefix
= "struct";
1456 fp
->ctf_lookups
[0].ctl_len
= strlen (fp
->ctf_lookups
[0].ctl_prefix
);
1457 fp
->ctf_lookups
[0].ctl_hash
= fp
->ctf_structs
;
1458 fp
->ctf_lookups
[1].ctl_prefix
= "union";
1459 fp
->ctf_lookups
[1].ctl_len
= strlen (fp
->ctf_lookups
[1].ctl_prefix
);
1460 fp
->ctf_lookups
[1].ctl_hash
= fp
->ctf_unions
;
1461 fp
->ctf_lookups
[2].ctl_prefix
= "enum";
1462 fp
->ctf_lookups
[2].ctl_len
= strlen (fp
->ctf_lookups
[2].ctl_prefix
);
1463 fp
->ctf_lookups
[2].ctl_hash
= fp
->ctf_enums
;
1464 fp
->ctf_lookups
[3].ctl_prefix
= _CTF_NULLSTR
;
1465 fp
->ctf_lookups
[3].ctl_len
= strlen (fp
->ctf_lookups
[3].ctl_prefix
);
1466 fp
->ctf_lookups
[3].ctl_hash
= fp
->ctf_names
;
1467 fp
->ctf_lookups
[4].ctl_prefix
= NULL
;
1468 fp
->ctf_lookups
[4].ctl_len
= 0;
1469 fp
->ctf_lookups
[4].ctl_hash
= NULL
;
1471 if (symsect
!= NULL
)
1473 if (symsect
->cts_entsize
== sizeof (Elf64_Sym
))
1474 (void) ctf_setmodel (fp
, CTF_MODEL_LP64
);
1476 (void) ctf_setmodel (fp
, CTF_MODEL_ILP32
);
1479 (void) ctf_setmodel (fp
, CTF_MODEL_NATIVE
);
1485 ctf_file_close (fp
);
1489 /* Close the specified CTF container and free associated data structures. Note
1490 that ctf_file_close() is a reference counted operation: if the specified file
1491 is the parent of other active containers, its reference count will be greater
1492 than one and it will be freed later when no active children exist. */
1495 ctf_file_close (ctf_file_t
*fp
)
1497 ctf_dtdef_t
*dtd
, *ntd
;
1498 ctf_dvdef_t
*dvd
, *nvd
;
1501 return; /* Allow ctf_file_close(NULL) to simplify caller code. */
1503 ctf_dprintf ("ctf_file_close(%p) refcnt=%u\n", (void *) fp
, fp
->ctf_refcnt
);
1505 if (fp
->ctf_refcnt
> 1)
1511 if (fp
->ctf_dynparname
!= NULL
)
1512 ctf_free (fp
->ctf_dynparname
);
1514 if (fp
->ctf_parent
!= NULL
)
1515 ctf_file_close (fp
->ctf_parent
);
1517 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
1519 ntd
= ctf_list_next (dtd
);
1520 ctf_dtd_delete (fp
, dtd
);
1522 ctf_dynhash_destroy (fp
->ctf_dthash
);
1523 ctf_dynhash_destroy (fp
->ctf_dtbyname
);
1525 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
1527 nvd
= ctf_list_next (dvd
);
1528 ctf_dvd_delete (fp
, dvd
);
1530 ctf_dynhash_destroy (fp
->ctf_dvhash
);
1532 ctf_free (fp
->ctf_tmp_typeslice
);
1534 if (fp
->ctf_data
.cts_name
!= _CTF_NULLSTR
&&
1535 fp
->ctf_data
.cts_name
!= NULL
)
1536 ctf_free ((char *) fp
->ctf_data
.cts_name
);
1538 if (fp
->ctf_symtab
.cts_name
!= _CTF_NULLSTR
&&
1539 fp
->ctf_symtab
.cts_name
!= NULL
)
1540 ctf_free ((char *) fp
->ctf_symtab
.cts_name
);
1542 if (fp
->ctf_strtab
.cts_name
!= _CTF_NULLSTR
&&
1543 fp
->ctf_strtab
.cts_name
!= NULL
)
1544 ctf_free ((char *) fp
->ctf_strtab
.cts_name
);
1546 else if (fp
->ctf_data_mmapped
)
1547 ctf_munmap (fp
->ctf_data_mmapped
, fp
->ctf_data_mmapped_len
);
1549 ctf_free_base (fp
, NULL
);
1551 if (fp
->ctf_sxlate
!= NULL
)
1552 ctf_free (fp
->ctf_sxlate
);
1554 if (fp
->ctf_txlate
!= NULL
)
1555 ctf_free (fp
->ctf_txlate
);
1557 if (fp
->ctf_ptrtab
!= NULL
)
1558 ctf_free (fp
->ctf_ptrtab
);
1560 ctf_hash_destroy (fp
->ctf_structs
);
1561 ctf_hash_destroy (fp
->ctf_unions
);
1562 ctf_hash_destroy (fp
->ctf_enums
);
1563 ctf_hash_destroy (fp
->ctf_names
);
1568 /* The converse of ctf_open(). ctf_open() disguises whatever it opens as an
1569 archive, so closing one is just like closing an archive. */
1571 ctf_close (ctf_archive_t
*arc
)
1573 ctf_arc_close (arc
);
1576 /* Get the CTF archive from which this ctf_file_t is derived. */
1578 ctf_get_arc (const ctf_file_t
*fp
)
1580 return fp
->ctf_archive
;
1583 /* Return the ctfsect out of the core ctf_impl. Useful for freeing the
1584 ctfsect's data * after ctf_file_close(), which is why we return the actual
1585 structure, not a pointer to it, since that is likely to become a pointer to
1586 freed data before the return value is used under the expected use case of
1587 ctf_getsect()/ ctf_file_close()/free(). */
1589 ctf_getdatasect (const ctf_file_t
*fp
)
1591 return fp
->ctf_data
;
1594 /* Return the CTF handle for the parent CTF container, if one exists.
1595 Otherwise return NULL to indicate this container has no imported parent. */
1597 ctf_parent_file (ctf_file_t
*fp
)
1599 return fp
->ctf_parent
;
1602 /* Return the name of the parent CTF container, if one exists. Otherwise
1603 return NULL to indicate this container is a root container. */
1605 ctf_parent_name (ctf_file_t
*fp
)
1607 return fp
->ctf_parname
;
1610 /* Set the parent name. It is an error to call this routine without calling
1611 ctf_import() at some point. */
1613 ctf_parent_name_set (ctf_file_t
*fp
, const char *name
)
1615 if (fp
->ctf_dynparname
!= NULL
)
1616 ctf_free (fp
->ctf_dynparname
);
1618 fp
->ctf_dynparname
= ctf_strdup (name
);
1619 fp
->ctf_parname
= fp
->ctf_dynparname
;
1622 /* Import the types from the specified parent container by storing a pointer
1623 to it in ctf_parent and incrementing its reference count. Only one parent
1624 is allowed: if a parent already exists, it is replaced by the new parent. */
1626 ctf_import (ctf_file_t
*fp
, ctf_file_t
*pfp
)
1628 if (fp
== NULL
|| fp
== pfp
|| (pfp
!= NULL
&& pfp
->ctf_refcnt
== 0))
1629 return (ctf_set_errno (fp
, EINVAL
));
1631 if (pfp
!= NULL
&& pfp
->ctf_dmodel
!= fp
->ctf_dmodel
)
1632 return (ctf_set_errno (fp
, ECTF_DMODEL
));
1634 if (fp
->ctf_parent
!= NULL
)
1635 ctf_file_close (fp
->ctf_parent
);
1639 fp
->ctf_flags
|= LCTF_CHILD
;
1642 if (fp
->ctf_parname
== NULL
)
1643 ctf_parent_name_set (fp
, "PARENT");
1645 fp
->ctf_parent
= pfp
;
1649 /* Set the data model constant for the CTF container. */
1651 ctf_setmodel (ctf_file_t
*fp
, int model
)
1653 const ctf_dmodel_t
*dp
;
1655 for (dp
= _libctf_models
; dp
->ctd_name
!= NULL
; dp
++)
1657 if (dp
->ctd_code
== model
)
1659 fp
->ctf_dmodel
= dp
;
1664 return (ctf_set_errno (fp
, EINVAL
));
1667 /* Return the data model constant for the CTF container. */
1669 ctf_getmodel (ctf_file_t
*fp
)
1671 return fp
->ctf_dmodel
->ctd_code
;
1674 /* The caller can hang an arbitrary pointer off each ctf_file_t using this
1677 ctf_setspecific (ctf_file_t
*fp
, void *data
)
1679 fp
->ctf_specific
= data
;
1682 /* Retrieve the arbitrary pointer again. */
1684 ctf_getspecific (ctf_file_t
*fp
)
1686 return fp
->ctf_specific
;