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
, size_t ctf_size
)
360 base
= (unsigned char *) fp
->ctf_base
;
364 if (base
!= fp
->ctf_data
.cts_data
&& base
!= NULL
)
365 ctf_data_free (base
, size
);
368 /* Set the version of the CTF file. */
370 /* When this is reset, LCTF_* changes behaviour, but there is no guarantee that
371 the variable data list associated with each type has been upgraded: the
372 caller must ensure this has been done in advance. */
375 ctf_set_version (ctf_file_t
* fp
, ctf_header_t
* cth
, int ctf_version
)
377 fp
->ctf_version
= ctf_version
;
378 cth
->cth_version
= ctf_version
;
379 fp
->ctf_fileops
= &ctf_fileops
[ctf_version
];
382 /* Upgrade the type table to CTF_VERSION_3 (really CTF_VERSION_1_UPGRADED_3).
384 The upgrade is not done in-place: the ctf_base is moved. ctf_strptr() must
385 not be called before reallocation is complete.
387 Type kinds not checked here due to nonexistence in older formats:
390 upgrade_types (ctf_file_t
*fp
, ctf_header_t
*cth
)
392 const ctf_type_v1_t
*tbuf
;
393 const ctf_type_v1_t
*tend
;
394 unsigned char *ctf_base
, *old_ctf_base
= (unsigned char *) fp
->ctf_base
;
395 size_t old_ctf_size
= fp
->ctf_size
;
398 ssize_t increase
= 0, size
, increment
, v2increment
, vbytes
, v2bytes
;
399 const ctf_type_v1_t
*tp
;
401 ctf_header_t
*new_cth
;
403 tbuf
= (ctf_type_v1_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
404 tend
= (ctf_type_v1_t
*) (fp
->ctf_buf
+ cth
->cth_stroff
);
406 /* Much like init_types(), this is a two-pass process.
408 First, figure out the new type-section size needed. (It is possible,
409 in theory, for it to be less than the old size, but this is very
410 unlikely. It cannot be so small that cth_typeoff ends up of negative
411 size. We validate this with an assertion below.)
413 We must cater not only for changes in vlen and types sizes but also
414 for changes in 'increment', which happen because v2 places some types
415 into ctf_stype_t where v1 would be forced to use the larger non-stype. */
417 for (tp
= tbuf
; tp
< tend
;
418 tp
= (ctf_type_v1_t
*) ((uintptr_t) tp
+ increment
+ vbytes
))
420 unsigned short kind
= CTF_V1_INFO_KIND (tp
->ctt_info
);
421 unsigned long vlen
= CTF_V1_INFO_VLEN (tp
->ctt_info
);
423 size
= get_ctt_size_v1 (fp
, (const ctf_type_t
*) tp
, NULL
, &increment
);
424 vbytes
= get_vbytes_v1 (kind
, size
, vlen
);
426 get_ctt_size_v2_unconverted (fp
, (const ctf_type_t
*) tp
, NULL
,
428 v2bytes
= get_vbytes_v2 (kind
, size
, vlen
);
430 if ((vbytes
< 0) || (size
< 0))
433 increase
+= v2increment
- increment
; /* May be negative. */
434 increase
+= v2bytes
- vbytes
;
437 /* Allocate enough room for the new buffer, then copy everything but the
438 type section into place, and reset the base accordingly. Leave the
439 version number unchanged, so that LCTF_INFO_* still works on the
440 as-yet-untranslated type info. */
442 if ((ctf_base
= ctf_data_alloc (fp
->ctf_size
+ increase
)) == NULL
)
445 memcpy (ctf_base
, fp
->ctf_base
, sizeof (ctf_header_t
) + cth
->cth_typeoff
);
446 memcpy (ctf_base
+ sizeof (ctf_header_t
) + cth
->cth_stroff
+ increase
,
447 fp
->ctf_base
+ sizeof (ctf_header_t
) + cth
->cth_stroff
,
450 memset (ctf_base
+ sizeof (ctf_header_t
) + cth
->cth_typeoff
, 0,
451 cth
->cth_stroff
- cth
->cth_typeoff
+ increase
);
453 /* The cth here is an automatic variable in ctf_bufopen(), and transient
454 (a copy maintained because at that stage the header read out of the
455 ctf file may be read-only). We make all modifications in the
456 canonical copy at ctf_base (by now, writable), then copy it back into
459 new_cth
= (ctf_header_t
*) ctf_base
;
460 new_cth
->cth_stroff
+= increase
;
461 fp
->ctf_size
+= increase
;
462 assert (new_cth
->cth_stroff
>= new_cth
->cth_typeoff
);
463 ctf_set_base (fp
, new_cth
, ctf_base
);
465 t2buf
= (ctf_type_t
*) (fp
->ctf_buf
+ new_cth
->cth_typeoff
);
467 /* Iterate through all the types again, upgrading them.
469 Everything that hasn't changed can just be outright memcpy()ed.
470 Things that have changed need field-by-field consideration. */
472 for (tp
= tbuf
, t2p
= t2buf
; tp
< tend
;
473 tp
= (ctf_type_v1_t
*) ((uintptr_t) tp
+ increment
+ vbytes
),
474 t2p
= (ctf_type_t
*) ((uintptr_t) t2p
+ v2increment
+ v2bytes
))
476 unsigned short kind
= CTF_V1_INFO_KIND (tp
->ctt_info
);
477 int isroot
= CTF_V1_INFO_ISROOT (tp
->ctt_info
);
478 unsigned long vlen
= CTF_V1_INFO_VLEN (tp
->ctt_info
);
480 void *vdata
, *v2data
;
482 size
= get_ctt_size_v1 (fp
, (const ctf_type_t
*) tp
, NULL
, &increment
);
483 vbytes
= get_vbytes_v1 (kind
, size
, vlen
);
485 t2p
->ctt_name
= tp
->ctt_name
;
486 t2p
->ctt_info
= CTF_TYPE_INFO (kind
, isroot
, vlen
);
497 t2p
->ctt_type
= tp
->ctt_type
;
506 if ((size_t) size
<= CTF_MAX_SIZE
)
507 t2p
->ctt_size
= size
;
510 t2p
->ctt_lsizehi
= CTF_SIZE_TO_LSIZE_HI (size
);
511 t2p
->ctt_lsizelo
= CTF_SIZE_TO_LSIZE_LO (size
);
516 v2size
= get_ctt_size_v2 (fp
, t2p
, NULL
, &v2increment
);
517 v2bytes
= get_vbytes_v2 (kind
, v2size
, vlen
);
519 /* Catch out-of-sync get_ctt_size_*(). The count goes wrong if
520 these are not identical (and having them different makes no
521 sense semantically). */
523 assert (size
== v2size
);
525 /* Now the varlen info. */
527 vdata
= (void *) ((uintptr_t) tp
+ increment
);
528 v2data
= (void *) ((uintptr_t) t2p
+ v2increment
);
534 const ctf_array_v1_t
*ap
= (const ctf_array_v1_t
*) vdata
;
535 ctf_array_t
*a2p
= (ctf_array_t
*) v2data
;
537 a2p
->cta_contents
= ap
->cta_contents
;
538 a2p
->cta_index
= ap
->cta_index
;
539 a2p
->cta_nelems
= ap
->cta_nelems
;
546 const ctf_member_v1_t
*m1
= (const ctf_member_v1_t
*) vdata
;
547 const ctf_lmember_v1_t
*lm1
= (const ctf_lmember_v1_t
*) m1
;
548 ctf_member_t
*m2
= (ctf_member_t
*) v2data
;
549 ctf_lmember_t
*lm2
= (ctf_lmember_t
*) m2
;
552 /* We walk all four pointers forward, but only reference the two
553 that are valid for the given size, to avoid quadruplicating all
556 for (i
= vlen
; i
!= 0; i
--, m1
++, lm1
++, m2
++, lm2
++)
559 if (size
< CTF_LSTRUCT_THRESH_V1
)
561 offset
= m1
->ctm_offset
;
562 tmp
.ctm_name
= m1
->ctm_name
;
563 tmp
.ctm_type
= m1
->ctm_type
;
567 offset
= CTF_LMEM_OFFSET (lm1
);
568 tmp
.ctm_name
= lm1
->ctlm_name
;
569 tmp
.ctm_type
= lm1
->ctlm_type
;
571 if (size
< CTF_LSTRUCT_THRESH
)
573 m2
->ctm_name
= tmp
.ctm_name
;
574 m2
->ctm_type
= tmp
.ctm_type
;
575 m2
->ctm_offset
= offset
;
579 lm2
->ctlm_name
= tmp
.ctm_name
;
580 lm2
->ctlm_type
= tmp
.ctm_type
;
581 lm2
->ctlm_offsethi
= CTF_OFFSET_TO_LMEMHI (offset
);
582 lm2
->ctlm_offsetlo
= CTF_OFFSET_TO_LMEMLO (offset
);
590 unsigned short *a1
= (unsigned short *) vdata
;
591 uint32_t *a2
= (uint32_t *) v2data
;
593 for (i
= vlen
; i
!= 0; i
--, a1
++, a2
++)
598 /* Catch out-of-sync get_vbytes_*(). */
599 assert (vbytes
== v2bytes
);
600 memcpy (v2data
, vdata
, vbytes
);
604 /* Verify that the entire region was converted. If not, we are either
605 converting too much, or too little (leading to a buffer overrun either here
606 or at read time, in init_types().) */
608 assert ((size_t) t2p
- (size_t) fp
->ctf_buf
== new_cth
->cth_stroff
);
610 ctf_set_version (fp
, (ctf_header_t
*) ctf_base
, CTF_VERSION_1_UPGRADED_3
);
611 ctf_free_base (fp
, old_ctf_base
, old_ctf_size
);
612 memcpy (cth
, new_cth
, sizeof (ctf_header_t
));
617 /* Initialize the type ID translation table with the byte offset of each type,
618 and initialize the hash tables of each named type. Upgrade the type table to
619 the latest supported representation in the process, if needed, and if this
620 recension of libctf supports upgrading. */
623 init_types (ctf_file_t
*fp
, ctf_header_t
*cth
)
625 const ctf_type_t
*tbuf
;
626 const ctf_type_t
*tend
;
628 unsigned long pop
[CTF_K_MAX
+ 1] = { 0 };
629 const ctf_type_t
*tp
;
634 /* We determine whether the container is a child or a parent based on
635 the value of cth_parname. */
637 int child
= cth
->cth_parname
!= 0;
638 int nlstructs
= 0, nlunions
= 0;
641 if (_libctf_unlikely_ (fp
->ctf_version
== CTF_VERSION_1
))
644 if ((err
= upgrade_types (fp
, cth
)) != 0)
645 return err
; /* Upgrade failed. */
648 tbuf
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_typeoff
);
649 tend
= (ctf_type_t
*) (fp
->ctf_buf
+ cth
->cth_stroff
);
651 /* We make two passes through the entire type section. In this first
652 pass, we count the number of each type and the total number of types. */
654 for (tp
= tbuf
; tp
< tend
; fp
->ctf_typemax
++)
656 unsigned short kind
= LCTF_INFO_KIND (fp
, tp
->ctt_info
);
657 unsigned long vlen
= LCTF_INFO_VLEN (fp
, tp
->ctt_info
);
658 ssize_t size
, increment
, vbytes
;
660 (void) ctf_get_ctt_size (fp
, tp
, &size
, &increment
);
661 vbytes
= LCTF_VBYTES (fp
, kind
, size
, vlen
);
666 if (kind
== CTF_K_FORWARD
)
668 /* For forward declarations, ctt_type is the CTF_K_* kind for the tag,
669 so bump that population count too. If ctt_type is unknown, treat
670 the tag as a struct. */
672 if (tp
->ctt_type
== CTF_K_UNKNOWN
|| tp
->ctt_type
>= CTF_K_MAX
)
677 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
683 ctf_dprintf ("CTF container %p is a child\n", (void *) fp
);
684 fp
->ctf_flags
|= LCTF_CHILD
;
687 ctf_dprintf ("CTF container %p is a parent\n", (void *) fp
);
689 /* Now that we've counted up the number of each type, we can allocate
690 the hash tables, type translation table, and pointer table. */
692 if ((fp
->ctf_structs
= ctf_hash_create (pop
[CTF_K_STRUCT
], ctf_hash_string
,
693 ctf_hash_eq_string
)) == NULL
)
696 if ((fp
->ctf_unions
= ctf_hash_create (pop
[CTF_K_UNION
], ctf_hash_string
,
697 ctf_hash_eq_string
)) == NULL
)
700 if ((fp
->ctf_enums
= ctf_hash_create (pop
[CTF_K_ENUM
], ctf_hash_string
,
701 ctf_hash_eq_string
)) == NULL
)
704 if ((fp
->ctf_names
= ctf_hash_create (pop
[CTF_K_INTEGER
] +
706 pop
[CTF_K_FUNCTION
] +
709 pop
[CTF_K_VOLATILE
] +
713 ctf_hash_eq_string
)) == NULL
)
716 fp
->ctf_txlate
= ctf_alloc (sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
717 fp
->ctf_ptrtab
= ctf_alloc (sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
719 if (fp
->ctf_txlate
== NULL
|| fp
->ctf_ptrtab
== NULL
)
720 return ENOMEM
; /* Memory allocation failed. */
723 *xp
++ = 0; /* Type id 0 is used as a sentinel value. */
725 memset (fp
->ctf_txlate
, 0, sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
726 memset (fp
->ctf_ptrtab
, 0, sizeof (uint32_t) * (fp
->ctf_typemax
+ 1));
728 /* In the second pass through the types, we fill in each entry of the
729 type and pointer tables and add names to the appropriate hashes. */
731 for (id
= 1, tp
= tbuf
; tp
< tend
; xp
++, id
++)
733 unsigned short kind
= LCTF_INFO_KIND (fp
, tp
->ctt_info
);
734 unsigned short flag
= LCTF_INFO_ISROOT (fp
, tp
->ctt_info
);
735 unsigned long vlen
= LCTF_INFO_VLEN (fp
, tp
->ctt_info
);
736 ssize_t size
, increment
, vbytes
;
740 (void) ctf_get_ctt_size (fp
, tp
, &size
, &increment
);
741 name
= ctf_strptr (fp
, tp
->ctt_name
);
742 vbytes
= LCTF_VBYTES (fp
, kind
, size
, vlen
);
748 /* Names are reused by bit-fields, which are differentiated by their
749 encodings, and so typically we'd record only the first instance of
750 a given intrinsic. However, we replace an existing type with a
751 root-visible version so that we can be sure to find it when
752 checking for conflicting definitions in ctf_add_type(). */
754 if (((ctf_hash_lookup_type (fp
->ctf_names
, fp
, name
)) == 0)
755 || (flag
& CTF_ADD_ROOT
))
757 err
= ctf_hash_define_type (fp
->ctf_names
, fp
,
758 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
760 if (err
!= 0 && err
!= ECTF_STRTAB
)
765 /* These kinds have no name, so do not need interning into any
772 err
= ctf_hash_insert_type (fp
->ctf_names
, fp
,
773 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
775 if (err
!= 0 && err
!= ECTF_STRTAB
)
780 err
= ctf_hash_define_type (fp
->ctf_structs
, fp
,
781 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
784 if (err
!= 0 && err
!= ECTF_STRTAB
)
787 if (size
>= CTF_LSTRUCT_THRESH
)
792 err
= ctf_hash_define_type (fp
->ctf_unions
, fp
,
793 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
796 if (err
!= 0 && err
!= ECTF_STRTAB
)
799 if (size
>= CTF_LSTRUCT_THRESH
)
804 err
= ctf_hash_define_type (fp
->ctf_enums
, fp
,
805 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
808 if (err
!= 0 && err
!= ECTF_STRTAB
)
813 err
= ctf_hash_insert_type (fp
->ctf_names
, fp
,
814 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
816 if (err
!= 0 && err
!= ECTF_STRTAB
)
821 /* Only insert forward tags into the given hash if the type or tag
822 name is not already present. */
823 switch (tp
->ctt_type
)
826 hp
= fp
->ctf_structs
;
835 hp
= fp
->ctf_structs
;
838 if (ctf_hash_lookup_type (hp
, fp
, name
) == 0)
840 err
= ctf_hash_insert_type (hp
, fp
,
841 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
843 if (err
!= 0 && err
!= ECTF_STRTAB
)
849 /* If the type referenced by the pointer is in this CTF container,
850 then store the index of the pointer type in
851 fp->ctf_ptrtab[ index of referenced type ]. */
853 if (LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
854 && LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
855 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = id
;
861 err
= ctf_hash_insert_type (fp
->ctf_names
, fp
,
862 LCTF_INDEX_TO_TYPE (fp
, id
, child
),
864 if (err
!= 0 && err
!= ECTF_STRTAB
)
869 *xp
= (uint32_t) ((uintptr_t) tp
- (uintptr_t) fp
->ctf_buf
);
870 tp
= (ctf_type_t
*) ((uintptr_t) tp
+ increment
+ vbytes
);
873 ctf_dprintf ("%lu total types processed\n", fp
->ctf_typemax
);
874 ctf_dprintf ("%u enum names hashed\n", ctf_hash_size (fp
->ctf_enums
));
875 ctf_dprintf ("%u struct names hashed (%d long)\n",
876 ctf_hash_size (fp
->ctf_structs
), nlstructs
);
877 ctf_dprintf ("%u union names hashed (%d long)\n",
878 ctf_hash_size (fp
->ctf_unions
), nlunions
);
879 ctf_dprintf ("%u base type names hashed\n", ctf_hash_size (fp
->ctf_names
));
881 /* Make an additional pass through the pointer table to find pointers that
882 point to anonymous typedef nodes. If we find one, modify the pointer table
883 so that the pointer is also known to point to the node that is referenced
884 by the anonymous typedef node. */
886 for (id
= 1; id
<= fp
->ctf_typemax
; id
++)
888 if ((dst
= fp
->ctf_ptrtab
[id
]) != 0)
890 tp
= LCTF_INDEX_TO_TYPEPTR (fp
, id
);
892 if (LCTF_INFO_KIND (fp
, tp
->ctt_info
) == CTF_K_TYPEDEF
&&
893 strcmp (ctf_strptr (fp
, tp
->ctt_name
), "") == 0 &&
894 LCTF_TYPE_ISCHILD (fp
, tp
->ctt_type
) == child
&&
895 LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
) <= fp
->ctf_typemax
)
896 fp
->ctf_ptrtab
[LCTF_TYPE_TO_INDEX (fp
, tp
->ctt_type
)] = dst
;
903 /* Endianness-flipping routines.
905 We flip everything, mindlessly, even 1-byte entities, so that future
906 expansions do not require changes to this code. */
908 /* < C11? define away static assertions. */
910 #if !defined (__STDC_VERSION__) || __STDC_VERSION__ < 201112L
911 #define _Static_assert(cond, err)
914 /* Swap the endianness of something. */
916 #define swap_thing(x) \
918 _Static_assert (sizeof (x) == 1 || (sizeof (x) % 2 == 0 \
919 && sizeof (x) <= 8), \
920 "Invalid size, update endianness code"); \
921 switch (sizeof (x)) { \
922 case 2: x = bswap_16 (x); break; \
923 case 4: x = bswap_32 (x); break; \
924 case 8: x = bswap_64 (x); break; \
925 case 1: /* Nothing needs doing */ \
930 /* Flip the endianness of the CTF header. */
933 flip_header (ctf_header_t
*cth
)
935 swap_thing (cth
->cth_preamble
.ctp_magic
);
936 swap_thing (cth
->cth_preamble
.ctp_version
);
937 swap_thing (cth
->cth_preamble
.ctp_flags
);
938 swap_thing (cth
->cth_parlabel
);
939 swap_thing (cth
->cth_parname
);
940 swap_thing (cth
->cth_objtoff
);
941 swap_thing (cth
->cth_funcoff
);
942 swap_thing (cth
->cth_varoff
);
943 swap_thing (cth
->cth_typeoff
);
944 swap_thing (cth
->cth_stroff
);
945 swap_thing (cth
->cth_strlen
);
948 /* Flip the endianness of the label section, an array of ctf_lblent_t. */
951 flip_lbls (void *start
, size_t len
)
953 ctf_lblent_t
*lbl
= start
;
955 for (ssize_t i
= len
/ sizeof (struct ctf_lblent
); i
> 0; lbl
++, i
--)
957 swap_thing (lbl
->ctl_label
);
958 swap_thing (lbl
->ctl_type
);
962 /* Flip the endianness of the data-object or function sections, an array of
963 uint32_t. (The function section has more internal structure, but that
964 structure is an array of uint32_t, so can be treated as one big array for
968 flip_objts (void *start
, size_t len
)
970 uint32_t *obj
= start
;
972 for (ssize_t i
= len
/ sizeof (uint32_t); i
> 0; obj
++, i
--)
976 /* Flip the endianness of the variable section, an array of ctf_varent_t. */
979 flip_vars (void *start
, size_t len
)
981 ctf_varent_t
*var
= start
;
983 for (ssize_t i
= len
/ sizeof (struct ctf_varent
); i
> 0; var
++, i
--)
985 swap_thing (var
->ctv_name
);
986 swap_thing (var
->ctv_type
);
990 /* Flip the endianness of the type section, a tagged array of ctf_type or
991 ctf_stype followed by variable data. */
994 flip_types (void *start
, size_t len
)
996 ctf_type_t
*t
= start
;
998 while ((uintptr_t) t
< ((uintptr_t) start
) + len
)
1000 swap_thing (t
->ctt_name
);
1001 swap_thing (t
->ctt_info
);
1002 swap_thing (t
->ctt_size
);
1004 uint32_t kind
= CTF_V2_INFO_KIND (t
->ctt_info
);
1005 size_t size
= t
->ctt_size
;
1006 uint32_t vlen
= CTF_V2_INFO_VLEN (t
->ctt_info
);
1007 size_t vbytes
= get_vbytes_v2 (kind
, size
, vlen
);
1009 if (_libctf_unlikely_ (size
== CTF_LSIZE_SENT
))
1011 swap_thing (t
->ctt_lsizehi
);
1012 swap_thing (t
->ctt_lsizelo
);
1013 size
= CTF_TYPE_LSIZE (t
);
1014 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_type_t
));
1017 t
= (ctf_type_t
*) ((uintptr_t) t
+ sizeof (ctf_stype_t
));
1025 case CTF_K_VOLATILE
:
1027 case CTF_K_RESTRICT
:
1028 /* These types have no vlen data to swap. */
1029 assert (vbytes
== 0);
1035 /* These types have a single uint32_t. */
1037 uint32_t *item
= (uint32_t *) t
;
1043 case CTF_K_FUNCTION
:
1045 /* This type has a bunch of uint32_ts. */
1047 uint32_t *item
= (uint32_t *) t
;
1049 for (ssize_t i
= vlen
; i
> 0; item
++, i
--)
1056 /* This has a single ctf_array_t. */
1058 ctf_array_t
*a
= (ctf_array_t
*) t
;
1060 assert (vbytes
== sizeof (ctf_array_t
));
1061 swap_thing (a
->cta_contents
);
1062 swap_thing (a
->cta_index
);
1063 swap_thing (a
->cta_nelems
);
1070 /* This has a single ctf_slice_t. */
1072 ctf_slice_t
*s
= (ctf_slice_t
*) t
;
1074 assert (vbytes
== sizeof (ctf_slice_t
));
1075 swap_thing (s
->cts_type
);
1076 swap_thing (s
->cts_offset
);
1077 swap_thing (s
->cts_bits
);
1085 /* This has an array of ctf_member or ctf_lmember, depending on
1086 size. We could consider it to be a simple array of uint32_t,
1087 but for safety's sake in case these structures ever acquire
1088 non-uint32_t members, do it member by member. */
1090 if (_libctf_unlikely_ (size
>= CTF_LSTRUCT_THRESH
))
1092 ctf_lmember_t
*lm
= (ctf_lmember_t
*) t
;
1093 for (ssize_t i
= vlen
; i
> 0; i
--, lm
++)
1095 swap_thing (lm
->ctlm_name
);
1096 swap_thing (lm
->ctlm_offsethi
);
1097 swap_thing (lm
->ctlm_type
);
1098 swap_thing (lm
->ctlm_offsetlo
);
1103 ctf_member_t
*m
= (ctf_member_t
*) t
;
1104 for (ssize_t i
= vlen
; i
> 0; i
--, m
++)
1106 swap_thing (m
->ctm_name
);
1107 swap_thing (m
->ctm_offset
);
1108 swap_thing (m
->ctm_type
);
1116 /* This has an array of ctf_enum_t. */
1118 ctf_enum_t
*item
= (ctf_enum_t
*) t
;
1120 for (ssize_t i
= vlen
; i
> 0; item
++, i
--)
1122 swap_thing (item
->cte_name
);
1123 swap_thing (item
->cte_value
);
1128 ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n",
1130 return ECTF_CORRUPT
;
1133 t
= (ctf_type_t
*) ((uintptr_t) t
+ vbytes
);
1139 /* Flip the endianness of BASE, given the offsets in the (already endian-
1142 All of this stuff happens before the header is fully initialized, so the
1143 LCTF_*() macros cannot be used yet. Since we do not try to endian-convert v1
1144 data, this is no real loss. */
1147 flip_ctf (ctf_header_t
*cth
, unsigned char *base
)
1149 base
+= sizeof (ctf_header_t
);
1151 flip_lbls (base
+ cth
->cth_lbloff
, cth
->cth_objtoff
- cth
->cth_lbloff
);
1152 flip_objts (base
+ cth
->cth_objtoff
, cth
->cth_funcoff
- cth
->cth_objtoff
);
1153 flip_objts (base
+ cth
->cth_funcoff
, cth
->cth_varoff
- cth
->cth_funcoff
);
1154 flip_vars (base
+ cth
->cth_varoff
, cth
->cth_typeoff
- cth
->cth_varoff
);
1155 return flip_types (base
+ cth
->cth_typeoff
, cth
->cth_stroff
- cth
->cth_typeoff
);
1158 /* Open a CTF file, mocking up a suitable ctf_sect. */
1159 ctf_file_t
*ctf_simple_open (const char *ctfsect
, size_t ctfsect_size
,
1160 const char *symsect
, size_t symsect_size
,
1161 size_t symsect_entsize
,
1162 const char *strsect
, size_t strsect_size
,
1165 ctf_sect_t skeleton
;
1167 ctf_sect_t ctf_sect
, sym_sect
, str_sect
;
1168 ctf_sect_t
*ctfsectp
= NULL
;
1169 ctf_sect_t
*symsectp
= NULL
;
1170 ctf_sect_t
*strsectp
= NULL
;
1172 skeleton
.cts_name
= _CTF_SECTION
;
1173 skeleton
.cts_entsize
= 1;
1177 memcpy (&ctf_sect
, &skeleton
, sizeof (struct ctf_sect
));
1178 ctf_sect
.cts_data
= ctfsect
;
1179 ctf_sect
.cts_size
= ctfsect_size
;
1180 ctfsectp
= &ctf_sect
;
1185 memcpy (&sym_sect
, &skeleton
, sizeof (struct ctf_sect
));
1186 sym_sect
.cts_data
= symsect
;
1187 sym_sect
.cts_size
= symsect_size
;
1188 sym_sect
.cts_entsize
= symsect_entsize
;
1189 symsectp
= &sym_sect
;
1194 memcpy (&str_sect
, &skeleton
, sizeof (struct ctf_sect
));
1195 str_sect
.cts_data
= strsect
;
1196 str_sect
.cts_size
= strsect_size
;
1197 strsectp
= &str_sect
;
1200 return ctf_bufopen (ctfsectp
, symsectp
, strsectp
, errp
);
1203 /* Decode the specified CTF buffer and optional symbol table, and create a new
1204 CTF container representing the symbolic debugging information. This code can
1205 be used directly by the debugger, or it can be used as the engine for
1206 ctf_fdopen() or ctf_open(), below. */
1209 ctf_bufopen (const ctf_sect_t
*ctfsect
, const ctf_sect_t
*symsect
,
1210 const ctf_sect_t
*strsect
, int *errp
)
1212 const ctf_preamble_t
*pp
;
1217 int foreign_endian
= 0;
1220 libctf_init_debug();
1222 if (ctfsect
== NULL
|| ((symsect
== NULL
) != (strsect
== NULL
)))
1223 return (ctf_set_open_errno (errp
, EINVAL
));
1225 if (symsect
!= NULL
&& symsect
->cts_entsize
!= sizeof (Elf32_Sym
) &&
1226 symsect
->cts_entsize
!= sizeof (Elf64_Sym
))
1227 return (ctf_set_open_errno (errp
, ECTF_SYMTAB
));
1229 if (symsect
!= NULL
&& symsect
->cts_data
== NULL
)
1230 return (ctf_set_open_errno (errp
, ECTF_SYMBAD
));
1232 if (strsect
!= NULL
&& strsect
->cts_data
== NULL
)
1233 return (ctf_set_open_errno (errp
, ECTF_STRBAD
));
1235 if (ctfsect
->cts_size
< sizeof (ctf_preamble_t
))
1236 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1238 pp
= (const ctf_preamble_t
*) ctfsect
->cts_data
;
1240 ctf_dprintf ("ctf_bufopen: magic=0x%x version=%u\n",
1241 pp
->ctp_magic
, pp
->ctp_version
);
1243 /* Validate each part of the CTF header.
1245 First, we validate the preamble (common to all versions). At that point,
1246 we know the endianness and specific header version, and can validate the
1247 version-specific parts including section offsets and alignments.
1249 We specifically do not support foreign-endian old versions. */
1251 if (_libctf_unlikely_ (pp
->ctp_magic
!= CTF_MAGIC
))
1253 if (pp
->ctp_magic
== bswap_16 (CTF_MAGIC
))
1255 if (pp
->ctp_version
!= CTF_VERSION_3
)
1256 return (ctf_set_open_errno (errp
, ECTF_CTFVERS
));
1260 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1263 if (_libctf_unlikely_ ((pp
->ctp_version
< CTF_VERSION_1
)
1264 || (pp
->ctp_version
> CTF_VERSION_3
)))
1265 return (ctf_set_open_errno (errp
, ECTF_CTFVERS
));
1267 if ((symsect
!= NULL
) && (pp
->ctp_version
< CTF_VERSION_2
))
1269 /* The symtab can contain function entries which contain embedded ctf
1270 info. We do not support dynamically upgrading such entries (none
1271 should exist in any case, since dwarf2ctf does not create them). */
1273 ctf_dprintf ("ctf_bufopen: CTF version %d symsect not "
1274 "supported\n", pp
->ctp_version
);
1275 return (ctf_set_open_errno (errp
, ECTF_NOTSUP
));
1278 if (ctfsect
->cts_size
< sizeof (ctf_header_t
))
1279 return (ctf_set_open_errno (errp
, ECTF_NOCTFBUF
));
1281 memcpy (&hp
, ctfsect
->cts_data
, sizeof (hp
));
1286 hdrsz
= sizeof (ctf_header_t
);
1288 size
= hp
.cth_stroff
+ hp
.cth_strlen
;
1290 ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n", (unsigned long) size
);
1292 if (hp
.cth_lbloff
> size
|| hp
.cth_objtoff
> size
1293 || hp
.cth_funcoff
> size
|| hp
.cth_typeoff
> size
|| hp
.cth_stroff
> size
)
1294 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1296 if (hp
.cth_lbloff
> hp
.cth_objtoff
1297 || hp
.cth_objtoff
> hp
.cth_funcoff
1298 || hp
.cth_funcoff
> hp
.cth_typeoff
1299 || hp
.cth_funcoff
> hp
.cth_varoff
1300 || hp
.cth_varoff
> hp
.cth_typeoff
|| hp
.cth_typeoff
> hp
.cth_stroff
)
1301 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1303 if ((hp
.cth_lbloff
& 3) || (hp
.cth_objtoff
& 1)
1304 || (hp
.cth_funcoff
& 1) || (hp
.cth_varoff
& 3) || (hp
.cth_typeoff
& 3))
1305 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1307 /* Once everything is determined to be valid, attempt to decompress the CTF
1308 data buffer if it is compressed, or copy it into new storage if it is not
1309 compressed but needs endian-flipping. Otherwise we just put the data
1310 section's buffer pointer into ctf_buf, below. */
1312 /* Note: if this is a v1 buffer, it will be reallocated and expanded by
1315 if (hp
.cth_flags
& CTF_F_COMPRESS
)
1322 if ((base
= ctf_data_alloc (size
+ hdrsz
)) == NULL
)
1323 return (ctf_set_open_errno (errp
, ECTF_ZALLOC
));
1325 memcpy (base
, ctfsect
->cts_data
, hdrsz
);
1326 ((ctf_preamble_t
*) base
)->ctp_flags
&= ~CTF_F_COMPRESS
;
1327 buf
= (unsigned char *) base
+ hdrsz
;
1329 src
= (unsigned char *) ctfsect
->cts_data
+ hdrsz
;
1330 srclen
= ctfsect
->cts_size
- hdrsz
;
1333 if ((rc
= uncompress (buf
, &dstlen
, src
, srclen
)) != Z_OK
)
1335 ctf_dprintf ("zlib inflate err: %s\n", zError (rc
));
1336 ctf_data_free (base
, size
+ hdrsz
);
1337 return (ctf_set_open_errno (errp
, ECTF_DECOMPRESS
));
1340 if ((size_t) dstlen
!= size
)
1342 ctf_dprintf ("zlib inflate short -- got %lu of %lu "
1343 "bytes\n", (unsigned long) dstlen
, (unsigned long) size
);
1344 ctf_data_free (base
, size
+ hdrsz
);
1345 return (ctf_set_open_errno (errp
, ECTF_CORRUPT
));
1349 else if (foreign_endian
)
1351 if ((base
= ctf_data_alloc (size
+ hdrsz
)) == NULL
)
1352 return (ctf_set_open_errno (errp
, ECTF_ZALLOC
));
1356 base
= (void *) ctfsect
->cts_data
;
1357 buf
= (unsigned char *) base
+ hdrsz
;
1360 /* Once we have uncompressed and validated the CTF data buffer, we can
1361 proceed with allocating a ctf_file_t and initializing it.
1363 Nothing that depends on buf or base should be set directly in this function
1364 before the init_types() call, because it may be reallocated during
1365 transparent upgrade if this recension of libctf is so configured: see
1366 ctf_set_base() and ctf_realloc_base(). */
1368 if ((fp
= ctf_alloc (sizeof (ctf_file_t
))) == NULL
)
1369 return (ctf_set_open_errno (errp
, ENOMEM
));
1371 memset (fp
, 0, sizeof (ctf_file_t
));
1372 ctf_set_version (fp
, &hp
, hp
.cth_version
);
1374 if (_libctf_unlikely_ (hp
.cth_version
< CTF_VERSION_2
))
1375 fp
->ctf_parmax
= CTF_MAX_PTYPE_V1
;
1377 fp
->ctf_parmax
= CTF_MAX_PTYPE
;
1379 memcpy (&fp
->ctf_data
, ctfsect
, sizeof (ctf_sect_t
));
1381 if (symsect
!= NULL
)
1383 memcpy (&fp
->ctf_symtab
, symsect
, sizeof (ctf_sect_t
));
1384 memcpy (&fp
->ctf_strtab
, strsect
, sizeof (ctf_sect_t
));
1387 if (fp
->ctf_data
.cts_name
!= NULL
)
1388 fp
->ctf_data
.cts_name
= ctf_strdup (fp
->ctf_data
.cts_name
);
1389 if (fp
->ctf_symtab
.cts_name
!= NULL
)
1390 fp
->ctf_symtab
.cts_name
= ctf_strdup (fp
->ctf_symtab
.cts_name
);
1391 if (fp
->ctf_strtab
.cts_name
!= NULL
)
1392 fp
->ctf_strtab
.cts_name
= ctf_strdup (fp
->ctf_strtab
.cts_name
);
1394 if (fp
->ctf_data
.cts_name
== NULL
)
1395 fp
->ctf_data
.cts_name
= _CTF_NULLSTR
;
1396 if (fp
->ctf_symtab
.cts_name
== NULL
)
1397 fp
->ctf_symtab
.cts_name
= _CTF_NULLSTR
;
1398 if (fp
->ctf_strtab
.cts_name
== NULL
)
1399 fp
->ctf_strtab
.cts_name
= _CTF_NULLSTR
;
1401 if (strsect
!= NULL
)
1403 fp
->ctf_str
[CTF_STRTAB_1
].cts_strs
= strsect
->cts_data
;
1404 fp
->ctf_str
[CTF_STRTAB_1
].cts_len
= strsect
->cts_size
;
1407 if (foreign_endian
&&
1408 (err
= flip_ctf (&hp
, base
)) != 0)
1410 /* We can be certain that flip_ctf() will have endian-flipped everything
1411 other than the types table when we return. In particular the header
1412 is fine, so set it, to allow freeing to use the usual code path. */
1414 (void) ctf_set_open_errno (errp
, err
);
1415 ctf_set_base (fp
, &hp
, base
);
1419 ctf_set_base (fp
, &hp
, base
);
1420 fp
->ctf_size
= size
+ hdrsz
;
1422 if ((err
= init_types (fp
, &hp
)) != 0)
1424 (void) ctf_set_open_errno (errp
, err
);
1428 /* The ctf region may have been reallocated by init_types(), but now
1429 that is done, it will not move again, so we can protect it, as long
1430 as it didn't come from the ctfsect, which might have been allocated
1433 if (fp
->ctf_base
!= (void *) ctfsect
->cts_data
)
1434 ctf_data_protect ((void *) fp
->ctf_base
, fp
->ctf_size
);
1436 /* If we have a symbol table section, allocate and initialize
1437 the symtab translation table, pointed to by ctf_sxlate. */
1439 if (symsect
!= NULL
)
1441 fp
->ctf_nsyms
= symsect
->cts_size
/ symsect
->cts_entsize
;
1442 fp
->ctf_sxlate
= ctf_alloc (fp
->ctf_nsyms
* sizeof (uint32_t));
1444 if (fp
->ctf_sxlate
== NULL
)
1446 (void) ctf_set_open_errno (errp
, ENOMEM
);
1450 if ((err
= init_symtab (fp
, &hp
, symsect
, strsect
)) != 0)
1452 (void) ctf_set_open_errno (errp
, err
);
1457 /* Initialize the ctf_lookup_by_name top-level dictionary. We keep an
1458 array of type name prefixes and the corresponding ctf_hash to use.
1459 NOTE: This code must be kept in sync with the code in ctf_update(). */
1460 fp
->ctf_lookups
[0].ctl_prefix
= "struct";
1461 fp
->ctf_lookups
[0].ctl_len
= strlen (fp
->ctf_lookups
[0].ctl_prefix
);
1462 fp
->ctf_lookups
[0].ctl_hash
= fp
->ctf_structs
;
1463 fp
->ctf_lookups
[1].ctl_prefix
= "union";
1464 fp
->ctf_lookups
[1].ctl_len
= strlen (fp
->ctf_lookups
[1].ctl_prefix
);
1465 fp
->ctf_lookups
[1].ctl_hash
= fp
->ctf_unions
;
1466 fp
->ctf_lookups
[2].ctl_prefix
= "enum";
1467 fp
->ctf_lookups
[2].ctl_len
= strlen (fp
->ctf_lookups
[2].ctl_prefix
);
1468 fp
->ctf_lookups
[2].ctl_hash
= fp
->ctf_enums
;
1469 fp
->ctf_lookups
[3].ctl_prefix
= _CTF_NULLSTR
;
1470 fp
->ctf_lookups
[3].ctl_len
= strlen (fp
->ctf_lookups
[3].ctl_prefix
);
1471 fp
->ctf_lookups
[3].ctl_hash
= fp
->ctf_names
;
1472 fp
->ctf_lookups
[4].ctl_prefix
= NULL
;
1473 fp
->ctf_lookups
[4].ctl_len
= 0;
1474 fp
->ctf_lookups
[4].ctl_hash
= NULL
;
1476 if (symsect
!= NULL
)
1478 if (symsect
->cts_entsize
== sizeof (Elf64_Sym
))
1479 (void) ctf_setmodel (fp
, CTF_MODEL_LP64
);
1481 (void) ctf_setmodel (fp
, CTF_MODEL_ILP32
);
1484 (void) ctf_setmodel (fp
, CTF_MODEL_NATIVE
);
1490 ctf_file_close (fp
);
1494 /* Close the specified CTF container and free associated data structures. Note
1495 that ctf_file_close() is a reference counted operation: if the specified file
1496 is the parent of other active containers, its reference count will be greater
1497 than one and it will be freed later when no active children exist. */
1500 ctf_file_close (ctf_file_t
*fp
)
1502 ctf_dtdef_t
*dtd
, *ntd
;
1503 ctf_dvdef_t
*dvd
, *nvd
;
1506 return; /* Allow ctf_file_close(NULL) to simplify caller code. */
1508 ctf_dprintf ("ctf_file_close(%p) refcnt=%u\n", (void *) fp
, fp
->ctf_refcnt
);
1510 if (fp
->ctf_refcnt
> 1)
1516 if (fp
->ctf_dynparname
!= NULL
)
1517 ctf_free (fp
->ctf_dynparname
);
1519 if (fp
->ctf_parent
!= NULL
)
1520 ctf_file_close (fp
->ctf_parent
);
1522 for (dtd
= ctf_list_next (&fp
->ctf_dtdefs
); dtd
!= NULL
; dtd
= ntd
)
1524 ntd
= ctf_list_next (dtd
);
1525 ctf_dtd_delete (fp
, dtd
);
1527 ctf_dynhash_destroy (fp
->ctf_dthash
);
1528 ctf_dynhash_destroy (fp
->ctf_dtbyname
);
1530 for (dvd
= ctf_list_next (&fp
->ctf_dvdefs
); dvd
!= NULL
; dvd
= nvd
)
1532 nvd
= ctf_list_next (dvd
);
1533 ctf_dvd_delete (fp
, dvd
);
1535 ctf_dynhash_destroy (fp
->ctf_dvhash
);
1537 ctf_free (fp
->ctf_tmp_typeslice
);
1539 if (fp
->ctf_data
.cts_name
!= _CTF_NULLSTR
&&
1540 fp
->ctf_data
.cts_name
!= NULL
)
1541 ctf_free ((char *) fp
->ctf_data
.cts_name
);
1543 if (fp
->ctf_symtab
.cts_name
!= _CTF_NULLSTR
&&
1544 fp
->ctf_symtab
.cts_name
!= NULL
)
1545 ctf_free ((char *) fp
->ctf_symtab
.cts_name
);
1547 if (fp
->ctf_strtab
.cts_name
!= _CTF_NULLSTR
&&
1548 fp
->ctf_strtab
.cts_name
!= NULL
)
1549 ctf_free ((char *) fp
->ctf_strtab
.cts_name
);
1551 else if (fp
->ctf_data_mmapped
)
1552 ctf_munmap (fp
->ctf_data_mmapped
, fp
->ctf_data_mmapped_len
);
1554 ctf_free_base (fp
, NULL
, 0);
1556 if (fp
->ctf_sxlate
!= NULL
)
1557 ctf_free (fp
->ctf_sxlate
);
1559 if (fp
->ctf_txlate
!= NULL
)
1560 ctf_free (fp
->ctf_txlate
);
1562 if (fp
->ctf_ptrtab
!= NULL
)
1563 ctf_free (fp
->ctf_ptrtab
);
1565 ctf_hash_destroy (fp
->ctf_structs
);
1566 ctf_hash_destroy (fp
->ctf_unions
);
1567 ctf_hash_destroy (fp
->ctf_enums
);
1568 ctf_hash_destroy (fp
->ctf_names
);
1573 /* The converse of ctf_open(). ctf_open() disguises whatever it opens as an
1574 archive, so closing one is just like closing an archive. */
1576 ctf_close (ctf_archive_t
*arc
)
1578 ctf_arc_close (arc
);
1581 /* Get the CTF archive from which this ctf_file_t is derived. */
1583 ctf_get_arc (const ctf_file_t
*fp
)
1585 return fp
->ctf_archive
;
1588 /* Return the ctfsect out of the core ctf_impl. Useful for freeing the
1589 ctfsect's data * after ctf_file_close(), which is why we return the actual
1590 structure, not a pointer to it, since that is likely to become a pointer to
1591 freed data before the return value is used under the expected use case of
1592 ctf_getsect()/ ctf_file_close()/free(). */
1594 ctf_getdatasect (const ctf_file_t
*fp
)
1596 return fp
->ctf_data
;
1599 /* Return the CTF handle for the parent CTF container, if one exists.
1600 Otherwise return NULL to indicate this container has no imported parent. */
1602 ctf_parent_file (ctf_file_t
*fp
)
1604 return fp
->ctf_parent
;
1607 /* Return the name of the parent CTF container, if one exists. Otherwise
1608 return NULL to indicate this container is a root container. */
1610 ctf_parent_name (ctf_file_t
*fp
)
1612 return fp
->ctf_parname
;
1615 /* Set the parent name. It is an error to call this routine without calling
1616 ctf_import() at some point. */
1618 ctf_parent_name_set (ctf_file_t
*fp
, const char *name
)
1620 if (fp
->ctf_dynparname
!= NULL
)
1621 ctf_free (fp
->ctf_dynparname
);
1623 fp
->ctf_dynparname
= ctf_strdup (name
);
1624 fp
->ctf_parname
= fp
->ctf_dynparname
;
1627 /* Import the types from the specified parent container by storing a pointer
1628 to it in ctf_parent and incrementing its reference count. Only one parent
1629 is allowed: if a parent already exists, it is replaced by the new parent. */
1631 ctf_import (ctf_file_t
*fp
, ctf_file_t
*pfp
)
1633 if (fp
== NULL
|| fp
== pfp
|| (pfp
!= NULL
&& pfp
->ctf_refcnt
== 0))
1634 return (ctf_set_errno (fp
, EINVAL
));
1636 if (pfp
!= NULL
&& pfp
->ctf_dmodel
!= fp
->ctf_dmodel
)
1637 return (ctf_set_errno (fp
, ECTF_DMODEL
));
1639 if (fp
->ctf_parent
!= NULL
)
1640 ctf_file_close (fp
->ctf_parent
);
1644 fp
->ctf_flags
|= LCTF_CHILD
;
1647 if (fp
->ctf_parname
== NULL
)
1648 ctf_parent_name_set (fp
, "PARENT");
1650 fp
->ctf_parent
= pfp
;
1654 /* Set the data model constant for the CTF container. */
1656 ctf_setmodel (ctf_file_t
*fp
, int model
)
1658 const ctf_dmodel_t
*dp
;
1660 for (dp
= _libctf_models
; dp
->ctd_name
!= NULL
; dp
++)
1662 if (dp
->ctd_code
== model
)
1664 fp
->ctf_dmodel
= dp
;
1669 return (ctf_set_errno (fp
, EINVAL
));
1672 /* Return the data model constant for the CTF container. */
1674 ctf_getmodel (ctf_file_t
*fp
)
1676 return fp
->ctf_dmodel
->ctd_code
;
1679 /* The caller can hang an arbitrary pointer off each ctf_file_t using this
1682 ctf_setspecific (ctf_file_t
*fp
, void *data
)
1684 fp
->ctf_specific
= data
;
1687 /* Retrieve the arbitrary pointer again. */
1689 ctf_getspecific (ctf_file_t
*fp
)
1691 return fp
->ctf_specific
;