1 /* Implementation header.
2 Copyright (C) 2019-2021 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/>. */
25 #include <sys/param.h>
26 #include "ctf-decls.h"
29 #include <sys/types.h>
48 /* The proportion of symtypetab entries which must be pads before we consider it
49 worthwhile to emit a symtypetab section as an index. Indexes cost time to
50 look up, but save space all told. Do not set to 1, since this will cause
51 indexes to be eschewed completely, even in child dicts, at considerable space
53 #define CTF_INDEX_PAD_THRESHOLD .75
55 /* Compiler attributes. */
57 #if defined (__GNUC__)
59 /* GCC. We assume that all compilers claiming to be GCC support sufficiently
60 many GCC attributes that the code below works. If some non-GCC compilers
61 masquerading as GCC in fact do not implement these attributes, version checks
64 /* We use the _libctf_*_ pattern to avoid clashes with any future attribute
65 macros glibc may introduce, which have names of the pattern
66 __attribute_blah__. */
68 #define _libctf_printflike_(string_index,first_to_check) \
69 __attribute__ ((__format__ (__printf__, (string_index), (first_to_check))))
70 #define _libctf_unlikely_(x) __builtin_expect ((x), 0)
71 #define _libctf_unused_ __attribute__ ((__unused__))
72 #define _libctf_malloc_ __attribute__((__malloc__))
73 #define _libctf_nonnull_(params) __attribute__((__nonnull__ params))
77 #define _libctf_printflike_(string_index,first_to_check)
78 #define _libctf_unlikely_(x) (x)
79 #define _libctf_unused_
80 #define _libctf_malloc_
81 #define _libctf_nonnull_(params)
86 #if defined (ENABLE_LIBCTF_HASH_DEBUGGING) && !defined (NDEBUG)
88 #define ctf_assert(fp, expr) (assert (expr), 1)
90 #define ctf_assert(fp, expr) \
91 _libctf_unlikely_ (ctf_assert_internal (fp, __FILE__, __LINE__, \
95 /* libctf in-memory state. */
97 typedef struct ctf_fixed_hash ctf_hash_t
; /* Private to ctf-hash.c. */
98 typedef struct ctf_dynhash ctf_dynhash_t
; /* Private to ctf-hash.c. */
99 typedef struct ctf_dynset ctf_dynset_t
; /* Private to ctf-hash.c. */
101 typedef struct ctf_strs
103 const char *cts_strs
; /* Base address of string table. */
104 size_t cts_len
; /* Size of string table in bytes. */
107 typedef struct ctf_strs_writable
109 char *cts_strs
; /* Base address of string table. */
110 size_t cts_len
; /* Size of string table in bytes. */
111 } ctf_strs_writable_t
;
113 typedef struct ctf_dmodel
115 const char *ctd_name
; /* Data model name. */
116 int ctd_code
; /* Data model code. */
117 size_t ctd_pointer
; /* Size of void * in bytes. */
118 size_t ctd_char
; /* Size of char in bytes. */
119 size_t ctd_short
; /* Size of short in bytes. */
120 size_t ctd_int
; /* Size of int in bytes. */
121 size_t ctd_long
; /* Size of long in bytes. */
124 typedef struct ctf_names
126 ctf_hash_t
*ctn_readonly
; /* Hash table when readonly. */
127 ctf_dynhash_t
*ctn_writable
; /* Hash table when writable. */
130 typedef struct ctf_lookup
132 const char *ctl_prefix
; /* String prefix for this lookup. */
133 size_t ctl_len
; /* Length of prefix string in bytes. */
134 ctf_names_t
*ctl_hash
; /* Pointer to hash table for lookup. */
137 typedef struct ctf_dictops
139 uint32_t (*ctfo_get_kind
) (uint32_t);
140 uint32_t (*ctfo_get_root
) (uint32_t);
141 uint32_t (*ctfo_get_vlen
) (uint32_t);
142 ssize_t (*ctfo_get_ctt_size
) (const ctf_dict_t
*, const ctf_type_t
*,
143 ssize_t
*, ssize_t
*);
144 ssize_t (*ctfo_get_vbytes
) (ctf_dict_t
*, unsigned short, ssize_t
, size_t);
147 typedef struct ctf_list
149 struct ctf_list
*l_prev
; /* Previous pointer or tail pointer. */
150 struct ctf_list
*l_next
; /* Next pointer or head pointer. */
162 typedef struct ctf_decl_node
164 ctf_list_t cd_list
; /* Linked list pointers. */
165 ctf_id_t cd_type
; /* Type identifier. */
166 uint32_t cd_kind
; /* Type kind. */
167 uint32_t cd_n
; /* Type dimension if array. */
170 typedef struct ctf_decl
172 ctf_list_t cd_nodes
[CTF_PREC_MAX
]; /* Declaration node stacks. */
173 int cd_order
[CTF_PREC_MAX
]; /* Storage order of decls. */
174 ctf_decl_prec_t cd_qualp
; /* Qualifier precision. */
175 ctf_decl_prec_t cd_ordp
; /* Ordered precision. */
176 char *cd_buf
; /* Buffer for output. */
177 int cd_err
; /* Saved error value. */
178 int cd_enomem
; /* Nonzero if OOM during printing. */
181 typedef struct ctf_dmdef
183 ctf_list_t dmd_list
; /* List forward/back pointers. */
184 char *dmd_name
; /* Name of this member. */
185 ctf_id_t dmd_type
; /* Type of this member (for sou). */
186 unsigned long dmd_offset
; /* Offset of this member in bits (for sou). */
187 int dmd_value
; /* Value of this member (for enum). */
190 typedef struct ctf_dtdef
192 ctf_list_t dtd_list
; /* List forward/back pointers. */
193 ctf_id_t dtd_type
; /* Type identifier for this definition. */
194 ctf_type_t dtd_data
; /* Type node, including name. */
197 ctf_list_t dtu_members
; /* struct, union, or enum */
198 ctf_arinfo_t dtu_arr
; /* array */
199 ctf_encoding_t dtu_enc
; /* integer or float */
200 uint32_t *dtu_argv
; /* function */
201 ctf_slice_t dtu_slice
; /* slice */
205 typedef struct ctf_dvdef
207 ctf_list_t dvd_list
; /* List forward/back pointers. */
208 char *dvd_name
; /* Name associated with variable. */
209 ctf_id_t dvd_type
; /* Type of variable. */
210 unsigned long dvd_snapshots
; /* Snapshot count when inserted. */
213 typedef struct ctf_err_warning
215 ctf_list_t cew_list
; /* List forward/back pointers. */
216 int cew_is_warning
; /* 1 if warning, 0 if error. */
217 char *cew_text
; /* Error/warning text. */
220 /* Atoms associate strings with a list of the CTF items that reference that
221 string, so that ctf_update() can instantiate all the strings using the
222 ctf_str_atoms and then reassociate them with the real string later.
224 Strings can be interned into ctf_str_atom without having refs associated
225 with them, for values that are returned to callers, etc. Items are only
226 removed from this table on ctf_close(), but on every ctf_update(), all the
227 csa_refs in all entries are purged. */
229 typedef struct ctf_str_atom
231 const char *csa_str
; /* Backpointer to string (hash key). */
232 ctf_list_t csa_refs
; /* This string's refs. */
233 uint32_t csa_offset
; /* Strtab offset, if any. */
234 uint32_t csa_external_offset
; /* External strtab offset, if any. */
235 unsigned long csa_snapshot_id
; /* Snapshot ID at time of creation. */
238 /* The refs of a single string in the atoms table. */
240 typedef struct ctf_str_atom_ref
242 ctf_list_t caf_list
; /* List forward/back pointers. */
243 uint32_t *caf_ref
; /* A single ref to this string. */
244 } ctf_str_atom_ref_t
;
246 /* A single linker-provided symbol, during symbol addition, possibly before we
247 have been given external strtab refs. */
248 typedef struct ctf_in_flight_dynsym
250 ctf_list_t cid_list
; /* List forward/back pointers. */
251 ctf_link_sym_t cid_sym
; /* The linker-known symbol. */
252 } ctf_in_flight_dynsym_t
;
254 /* The structure used as the key in a ctf_link_type_mapping. The value is a
255 type index, not a type ID. */
257 typedef struct ctf_link_type_key
261 } ctf_link_type_key_t
;
263 /* The structure used as the key in a cd_id_to_dict_t on 32-bit platforms. */
264 typedef struct ctf_type_id_key
270 /* Deduplicator state.
272 The dedup state below uses three terms consistently. A "hash" is a
273 ctf_dynhash_t; a "hash value" is the hash value of a type as returned by
274 ctf_dedup_hash_type; a "global type ID" or "global ID" is a packed-together
275 reference to a single ctf_dict_t (by array index in an array of inputs) and
276 ctf_id_t, i.e. a single instance of some hash value in some input.
278 The deduplication algorithm takes a bunch of inputs and yields a single
279 shared "output" and possibly many outputs corresponding to individual inputs
280 that still contain types after sharing of unconflicted types. Almost all
281 deduplicator state is stored in the struct ctf_dedup in the output, though a
282 (very) few things are stored in inputs for simplicity's sake, usually if they
283 are linking together things within the scope of a single TU.
285 Flushed at the end of every ctf_dedup run. */
287 typedef struct ctf_dedup
289 /* The CTF linker flags in force for this dedup run. */
292 /* On 32-bit platforms only, a hash of global type IDs, in the form of
293 a ctf_link_type_id_key_t. */
294 ctf_dynhash_t
*cd_id_to_dict_t
;
296 /* Atoms tables of decorated names: maps undecorated name to decorated name.
297 (The actual allocations are in the CTF dict for the former and the real
298 atoms table for the latter). Uses the same namespaces as ctf_lookups,
299 below, but has no need for null-termination. */
300 ctf_dynhash_t
*cd_decorated_names
[4];
302 /* Map type names to a hash from type hash value -> number of times each value
304 ctf_dynhash_t
*cd_name_counts
;
306 /* Map global type IDs to type hash values. Used to determine if types are
307 already hashed without having to recompute their hash values again, and to
308 link types together at later stages. Forwards that are peeked through to
309 structs and unions are not represented in here, so lookups that might be
310 such a type (in practice, all lookups) must go via cd_replaced_types first
311 to take this into account. Discarded before each rehashing. */
312 ctf_dynhash_t
*cd_type_hashes
;
314 /* Maps from the names of structs/unions/enums to a a single GID which is the
315 only appearance of that type in any input: if it appears in more than one
316 input, a value which is a GID with an input_num of -1 appears. Used in
317 share-duplicated link mode link modes to determine whether structs/unions
318 can be cited from multiple TUs. Only populated in that link mode. */
319 ctf_dynhash_t
*cd_struct_origin
;
321 /* Maps type hash values to a set of hash values of the types that cite them:
322 i.e., pointing backwards up the type graph. Used for recursive conflict
323 marking. Citations from tagged structures, unions, and forwards do not
324 appear in this graph. */
325 ctf_dynhash_t
*cd_citers
;
327 /* Maps type hash values to input global type IDs. The value is a set (a
328 hash) of global type IDs. Discarded before each rehashing. The result of
329 the ctf_dedup function. */
330 ctf_dynhash_t
*cd_output_mapping
;
332 /* A map giving the GID of the first appearance of each type for each type
334 ctf_dynhash_t
*cd_output_first_gid
;
336 /* Used to ensure that we never try to map a single type ID to more than one
338 ctf_dynhash_t
*cd_output_mapping_guard
;
340 /* Maps the global type IDs of structures in input TUs whose members still
341 need emission to the global type ID of the already-emitted target type
342 (which has no members yet) in the appropriate target. Uniquely, the latter
343 ID represents a *target* ID (i.e. the cd_output_mapping of some specified
344 input): we encode the shared (parent) dict with an ID of -1. */
345 ctf_dynhash_t
*cd_emission_struct_members
;
347 /* A set (a hash) of hash values of conflicting types. */
348 ctf_dynset_t
*cd_conflicting_types
;
350 /* Maps type hashes to ctf_id_t's in this dictionary. Populated only at
351 emission time, in the dictionary where emission is taking place. */
352 ctf_dynhash_t
*cd_output_emission_hashes
;
354 /* Maps the decorated names of conflicted cross-TU forwards that were forcibly
355 emitted in this TU to their emitted ctf_id_ts. Populated only at emission
356 time, in the dictionary where emission is taking place. */
357 ctf_dynhash_t
*cd_output_emission_conflicted_forwards
;
359 /* Points to the output counterpart of this input dictionary, at emission
361 ctf_dict_t
*cd_output
;
364 /* The ctf_dict is the structure used to represent a CTF dictionary to library
365 clients, who see it only as an opaque pointer. Modifications can therefore
366 be made freely to this structure without regard to client versioning. The
367 ctf_dict_t typedef appears in <ctf-api.h> and declares a forward tag.
368 (A ctf_file_t typedef also appears there, for historical reasons.)
370 NOTE: ctf_serialize() requires that everything inside of ctf_dict either be
371 an immediate value, a pointer to dynamically allocated data *outside* of the
372 ctf_dict itself, or a pointer to statically allocated data. If you add a
373 pointer to ctf_dict that points to something within the ctf_dict itself, you
374 must make corresponding changes to ctf_serialize(). */
378 const ctf_dictops_t
*ctf_dictops
; /* Version-specific dict operations. */
379 struct ctf_header
*ctf_header
; /* The header from this CTF dict. */
380 unsigned char ctf_openflags
; /* Flags the dict had when opened. */
381 ctf_sect_t ctf_data
; /* CTF data from object file. */
382 ctf_sect_t ctf_symtab
; /* Symbol table from object file. */
383 ctf_sect_t ctf_strtab
; /* String table from object file. */
384 int ctf_symsect_little_endian
; /* Endianness of the ctf_symtab. */
385 ctf_dynhash_t
*ctf_symhash
; /* (partial) hash, symsect name -> idx. */
386 size_t ctf_symhash_latest
; /* Amount of symsect scanned so far. */
387 ctf_dynhash_t
*ctf_prov_strtab
; /* Maps provisional-strtab offsets
389 ctf_dynhash_t
*ctf_syn_ext_strtab
; /* Maps ext-strtab offsets to names. */
390 void *ctf_data_mmapped
; /* CTF data we mmapped, to free later. */
391 size_t ctf_data_mmapped_len
; /* Length of CTF data we mmapped. */
392 ctf_names_t ctf_structs
; /* Hash table of struct types. */
393 ctf_names_t ctf_unions
; /* Hash table of union types. */
394 ctf_names_t ctf_enums
; /* Hash table of enum types. */
395 ctf_names_t ctf_names
; /* Hash table of remaining type names. */
396 ctf_lookup_t ctf_lookups
[5]; /* Pointers to nametabs for name lookup. */
397 ctf_strs_t ctf_str
[2]; /* Array of string table base and bounds. */
398 ctf_dynhash_t
*ctf_str_atoms
; /* Hash table of ctf_str_atoms_t. */
399 uint64_t ctf_str_num_refs
; /* Number of refs to cts_str_atoms. */
400 uint32_t ctf_str_prov_offset
; /* Latest provisional offset assigned so far. */
401 unsigned char *ctf_base
; /* CTF file pointer. */
402 unsigned char *ctf_dynbase
; /* Freeable CTF file pointer. */
403 unsigned char *ctf_buf
; /* Uncompressed CTF data buffer. */
404 size_t ctf_size
; /* Size of CTF header + uncompressed data. */
405 uint32_t *ctf_sxlate
; /* Translation table for unindexed symtypetab
407 unsigned long ctf_nsyms
; /* Number of entries in symtab xlate table. */
408 uint32_t *ctf_txlate
; /* Translation table for type IDs. */
409 uint32_t *ctf_ptrtab
; /* Translation table for pointer-to lookups. */
410 size_t ctf_ptrtab_len
; /* Num types storable in ptrtab currently. */
411 uint32_t *ctf_pptrtab
; /* Parent types pointed to by child dicts. */
412 size_t ctf_pptrtab_len
; /* Num types storable in pptrtab currently. */
413 uint32_t ctf_pptrtab_typemax
; /* Max child type when pptrtab last updated. */
414 uint32_t *ctf_funcidx_names
; /* Name of each function symbol in symtypetab
416 uint32_t *ctf_objtidx_names
; /* Likewise, for object symbols. */
417 size_t ctf_nfuncidx
; /* Number of funcidx entries. */
418 uint32_t *ctf_funcidx_sxlate
; /* Offsets into funcinfo for a given funcidx. */
419 uint32_t *ctf_objtidx_sxlate
; /* Likewise, for ctf_objtidx. */
420 size_t ctf_nobjtidx
; /* Number of objtidx entries. */
421 ctf_dynhash_t
*ctf_objthash
; /* name -> type ID. */
422 ctf_dynhash_t
*ctf_funchash
; /* name -> CTF_K_FUNCTION type ID. */
424 /* The next three are linker-derived state found in ctf_link targets only. */
426 ctf_dynhash_t
*ctf_dynsyms
; /* Symbol info from ctf_link_shuffle_syms. */
427 ctf_link_sym_t
**ctf_dynsymidx
; /* Indexes ctf_dynsyms by symidx. */
428 uint32_t ctf_dynsymmax
; /* Maximum ctf_dynsym index. */
429 ctf_list_t ctf_in_flight_dynsyms
; /* Dynsyms during accumulation. */
430 struct ctf_varent
*ctf_vars
; /* Sorted variable->type mapping. */
431 unsigned long ctf_nvars
; /* Number of variables in ctf_vars. */
432 unsigned long ctf_typemax
; /* Maximum valid type ID number. */
433 const ctf_dmodel_t
*ctf_dmodel
; /* Data model pointer (see above). */
434 const char *ctf_cuname
; /* Compilation unit name (if any). */
435 char *ctf_dyncuname
; /* Dynamically allocated name of CU. */
436 struct ctf_dict
*ctf_parent
; /* Parent CTF dict (if any). */
437 int ctf_parent_unreffed
; /* Parent set by ctf_import_unref? */
438 const char *ctf_parlabel
; /* Label in parent dict (if any). */
439 const char *ctf_parname
; /* Basename of parent (if any). */
440 char *ctf_dynparname
; /* Dynamically allocated name of parent. */
441 uint32_t ctf_parmax
; /* Highest type ID of a parent type. */
442 uint32_t ctf_refcnt
; /* Reference count (for parent links). */
443 uint32_t ctf_flags
; /* Libctf flags (see below). */
444 int ctf_errno
; /* Error code for most recent error. */
445 int ctf_version
; /* CTF data version. */
446 ctf_dynhash_t
*ctf_dthash
; /* Hash of dynamic type definitions. */
447 ctf_list_t ctf_dtdefs
; /* List of dynamic type definitions. */
448 ctf_dynhash_t
*ctf_dvhash
; /* Hash of dynamic variable mappings. */
449 ctf_list_t ctf_dvdefs
; /* List of dynamic variable definitions. */
450 unsigned long ctf_dtoldid
; /* Oldest id that has been committed. */
451 unsigned long ctf_snapshots
; /* ctf_snapshot() plus ctf_update() count. */
452 unsigned long ctf_snapshot_lu
; /* ctf_snapshot() call count at last update. */
453 ctf_archive_t
*ctf_archive
; /* Archive this ctf_dict_t came from. */
454 ctf_list_t ctf_errs_warnings
; /* CTF errors and warnings. */
455 ctf_dynhash_t
*ctf_link_inputs
; /* Inputs to this link. */
456 ctf_dynhash_t
*ctf_link_outputs
; /* Additional outputs from this link. */
458 /* Map input types to output types: populated in each output dict.
459 Key is a ctf_link_type_key_t: value is a type ID. Used by
460 nondeduplicating links and ad-hoc ctf_add_type calls only. */
461 ctf_dynhash_t
*ctf_link_type_mapping
;
463 /* Map input CU names to output CTF dict names: populated in the top-level
466 Key and value are dynamically-allocated strings. */
467 ctf_dynhash_t
*ctf_link_in_cu_mapping
;
469 /* Map output CTF dict names to input CU names: populated in the top-level
470 output dict. A hash of string to hash (set) of strings. Key and
471 individual value members are shared with ctf_link_in_cu_mapping. */
472 ctf_dynhash_t
*ctf_link_out_cu_mapping
;
474 /* CTF linker flags. Set on the parent output dict (the one passed to
475 ctf_link). Only respected when LCTF_LINKING set in ctf_flags. */
478 /* Allow the caller to change the name of link archive members. */
479 ctf_link_memb_name_changer_f
*ctf_link_memb_name_changer
;
480 void *ctf_link_memb_name_changer_arg
; /* Argument for it. */
482 /* Allow the caller to filter out variables they don't care about. */
483 ctf_link_variable_filter_f
*ctf_link_variable_filter
;
484 void *ctf_link_variable_filter_arg
; /* Argument for it. */
486 ctf_dynhash_t
*ctf_add_processing
; /* Types ctf_add_type is working on now. */
488 /* Atoms table for dedup string storage. All strings in the ctf_dedup_t are
489 stored here. Only the _alloc copy is allocated or freed: the
490 ctf_dedup_atoms may be pointed to some other CTF dict, to share its atoms.
491 We keep the atoms table outside the ctf_dedup so that atoms can be
492 preserved across multiple similar links, such as when doing cu-mapped
494 ctf_dynset_t
*ctf_dedup_atoms
;
495 ctf_dynset_t
*ctf_dedup_atoms_alloc
;
497 ctf_dedup_t ctf_dedup
; /* Deduplicator state. */
499 char *ctf_tmp_typeslice
; /* Storage for slicing up type names. */
500 size_t ctf_tmp_typeslicelen
; /* Size of the typeslice. */
501 void *ctf_specific
; /* Data for ctf_get/setspecific(). */
504 /* An abstraction over both a ctf_dict_t and a ctf_archive_t. */
506 struct ctf_archive_internal
509 int ctfi_unmap_on_close
;
510 ctf_dict_t
*ctfi_dict
;
511 struct ctf_archive
*ctfi_archive
;
512 ctf_dynhash_t
*ctfi_dicts
; /* Dicts we have opened and cached. */
513 ctf_dict_t
*ctfi_crossdict_cache
; /* Cross-dict caching. */
514 ctf_dict_t
**ctfi_symdicts
; /* Array of index -> ctf_dict_t *. */
515 ctf_dynhash_t
*ctfi_symnamedicts
; /* Hash of name -> ctf_dict_t *. */
516 ctf_sect_t ctfi_symsect
;
517 int ctfi_symsect_little_endian
; /* -1 for unknown / do not set. */
518 ctf_sect_t ctfi_strsect
;
519 int ctfi_free_symsect
;
520 int ctfi_free_strsect
;
522 bfd
*ctfi_abfd
; /* Optional source of section data. */
523 void (*ctfi_bfd_close
) (struct ctf_archive_internal
*);
526 /* Iterator state for the *_next() functions. */
528 /* A single hash key/value pair. */
529 typedef struct ctf_next_hkv
537 void (*ctn_iter_fun
) (void);
540 ssize_t ctn_increment
;
543 /* Some iterators contain other iterators, in addition to their other
545 ctf_next_t
*ctn_next
;
547 /* We can save space on this side of things by noting that a dictionary is
548 either dynamic or not, as a whole, and a given iterator can only iterate
549 over one kind of thing at once: so we can overlap the DTD and non-DTD
550 members, and the structure, variable and enum members, etc. */
553 const ctf_member_t
*ctn_mp
;
554 const ctf_lmember_t
*ctn_lmp
;
555 const ctf_dmdef_t
*ctn_dmd
;
556 const ctf_enum_t
*ctn_en
;
557 const ctf_dvdef_t
*ctn_dvd
;
558 ctf_next_hkv_t
*ctn_sorted_hkv
;
559 void **ctn_hash_slot
;
562 /* This union is of various sorts of dict we can iterate over:
563 currently dictionaries and archives, dynhashes, and dynsets. */
566 const ctf_dict_t
*ctn_fp
;
567 const ctf_archive_t
*ctn_arc
;
568 const ctf_dynhash_t
*ctn_h
;
569 const ctf_dynset_t
*ctn_s
;
573 /* Return x rounded up to an alignment boundary.
574 eg, P2ROUNDUP(0x1234, 0x100) == 0x1300 (0x13*align)
575 eg, P2ROUNDUP(0x5600, 0x100) == 0x5600 (0x56*align) */
576 #define P2ROUNDUP(x, align) (-(-(x) & -(align)))
578 /* * If an offs is not aligned already then round it up and align it. */
579 #define LCTF_ALIGN_OFFS(offs, align) ((offs + (align - 1)) & ~(align - 1))
581 #define LCTF_TYPE_ISPARENT(fp, id) ((id) <= fp->ctf_parmax)
582 #define LCTF_TYPE_ISCHILD(fp, id) ((id) > fp->ctf_parmax)
583 #define LCTF_TYPE_TO_INDEX(fp, id) ((id) & (fp->ctf_parmax))
584 #define LCTF_INDEX_TO_TYPE(fp, id, child) (child ? ((id) | (fp->ctf_parmax+1)) : \
587 #define LCTF_INDEX_TO_TYPEPTR(fp, i) \
588 ((fp->ctf_flags & LCTF_RDWR) ? \
589 &(ctf_dtd_lookup (fp, LCTF_INDEX_TO_TYPE \
590 (fp, i, fp->ctf_flags & LCTF_CHILD))->dtd_data) : \
591 (ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)]))
593 #define LCTF_INFO_KIND(fp, info) ((fp)->ctf_dictops->ctfo_get_kind(info))
594 #define LCTF_INFO_ISROOT(fp, info) ((fp)->ctf_dictops->ctfo_get_root(info))
595 #define LCTF_INFO_VLEN(fp, info) ((fp)->ctf_dictops->ctfo_get_vlen(info))
596 #define LCTF_VBYTES(fp, kind, size, vlen) \
597 ((fp)->ctf_dictops->ctfo_get_vbytes(fp, kind, size, vlen))
599 #define LCTF_CHILD 0x0001 /* CTF dict is a child. */
600 #define LCTF_RDWR 0x0002 /* CTF dict is writable. */
601 #define LCTF_DIRTY 0x0004 /* CTF dict has been modified. */
602 #define LCTF_LINKING 0x0008 /* CTF link is underway: respect ctf_link_flags. */
604 extern ctf_names_t
*ctf_name_table (ctf_dict_t
*, int);
605 extern const ctf_type_t
*ctf_lookup_by_id (ctf_dict_t
**, ctf_id_t
);
606 extern ctf_id_t
ctf_lookup_by_rawname (ctf_dict_t
*, int, const char *);
607 extern ctf_id_t
ctf_lookup_by_rawhash (ctf_dict_t
*, ctf_names_t
*, const char *);
608 extern void ctf_set_ctl_hashes (ctf_dict_t
*);
610 extern int ctf_symtab_skippable (ctf_link_sym_t
*sym
);
611 extern int ctf_add_funcobjt_sym (ctf_dict_t
*, int is_function
,
612 const char *, ctf_id_t
);
614 extern ctf_dict_t
*ctf_get_dict (ctf_dict_t
*fp
, ctf_id_t type
);
616 typedef unsigned int (*ctf_hash_fun
) (const void *ptr
);
617 extern unsigned int ctf_hash_integer (const void *ptr
);
618 extern unsigned int ctf_hash_string (const void *ptr
);
619 extern unsigned int ctf_hash_type_key (const void *ptr
);
620 extern unsigned int ctf_hash_type_id_key (const void *ptr
);
622 typedef int (*ctf_hash_eq_fun
) (const void *, const void *);
623 extern int ctf_hash_eq_integer (const void *, const void *);
624 extern int ctf_hash_eq_string (const void *, const void *);
625 extern int ctf_hash_eq_type_key (const void *, const void *);
626 extern int ctf_hash_eq_type_id_key (const void *, const void *);
628 extern int ctf_dynset_eq_string (const void *, const void *);
630 typedef void (*ctf_hash_free_fun
) (void *);
632 typedef void (*ctf_hash_iter_f
) (void *key
, void *value
, void *arg
);
633 typedef int (*ctf_hash_iter_remove_f
) (void *key
, void *value
, void *arg
);
634 typedef int (*ctf_hash_iter_find_f
) (void *key
, void *value
, void *arg
);
635 typedef int (*ctf_hash_sort_f
) (const ctf_next_hkv_t
*, const ctf_next_hkv_t
*,
638 extern ctf_hash_t
*ctf_hash_create (unsigned long, ctf_hash_fun
, ctf_hash_eq_fun
);
639 extern int ctf_hash_insert_type (ctf_hash_t
*, ctf_dict_t
*, uint32_t, uint32_t);
640 extern int ctf_hash_define_type (ctf_hash_t
*, ctf_dict_t
*, uint32_t, uint32_t);
641 extern ctf_id_t
ctf_hash_lookup_type (ctf_hash_t
*, ctf_dict_t
*, const char *);
642 extern uint32_t ctf_hash_size (const ctf_hash_t
*);
643 extern void ctf_hash_destroy (ctf_hash_t
*);
645 extern ctf_dynhash_t
*ctf_dynhash_create (ctf_hash_fun
, ctf_hash_eq_fun
,
646 ctf_hash_free_fun
, ctf_hash_free_fun
);
647 extern int ctf_dynhash_insert (ctf_dynhash_t
*, void *, void *);
648 extern void ctf_dynhash_remove (ctf_dynhash_t
*, const void *);
649 extern size_t ctf_dynhash_elements (ctf_dynhash_t
*);
650 extern void ctf_dynhash_empty (ctf_dynhash_t
*);
651 extern void *ctf_dynhash_lookup (ctf_dynhash_t
*, const void *);
652 extern int ctf_dynhash_lookup_kv (ctf_dynhash_t
*, const void *key
,
653 const void **orig_key
, void **value
);
654 extern void ctf_dynhash_destroy (ctf_dynhash_t
*);
655 extern void ctf_dynhash_iter (ctf_dynhash_t
*, ctf_hash_iter_f
, void *);
656 extern void ctf_dynhash_iter_remove (ctf_dynhash_t
*, ctf_hash_iter_remove_f
,
658 extern void *ctf_dynhash_iter_find (ctf_dynhash_t
*, ctf_hash_iter_find_f
,
660 extern int ctf_dynhash_sort_by_name (const ctf_next_hkv_t
*,
661 const ctf_next_hkv_t
*,
662 void * _libctf_unused_
);
663 extern int ctf_dynhash_next (ctf_dynhash_t
*, ctf_next_t
**,
664 void **key
, void **value
);
665 extern int ctf_dynhash_next_sorted (ctf_dynhash_t
*, ctf_next_t
**,
666 void **key
, void **value
, ctf_hash_sort_f
,
669 extern ctf_dynset_t
*ctf_dynset_create (htab_hash
, htab_eq
, ctf_hash_free_fun
);
670 extern int ctf_dynset_insert (ctf_dynset_t
*, void *);
671 extern void ctf_dynset_remove (ctf_dynset_t
*, const void *);
672 extern void ctf_dynset_destroy (ctf_dynset_t
*);
673 extern void *ctf_dynset_lookup (ctf_dynset_t
*, const void *);
674 extern int ctf_dynset_exists (ctf_dynset_t
*, const void *key
,
675 const void **orig_key
);
676 extern int ctf_dynset_next (ctf_dynset_t
*, ctf_next_t
**, void **key
);
677 extern void *ctf_dynset_lookup_any (ctf_dynset_t
*);
679 extern void ctf_sha1_init (ctf_sha1_t
*);
680 extern void ctf_sha1_add (ctf_sha1_t
*, const void *, size_t);
681 extern char *ctf_sha1_fini (ctf_sha1_t
*, char *);
683 #define ctf_list_prev(elem) ((void *)(((ctf_list_t *)(elem))->l_prev))
684 #define ctf_list_next(elem) ((void *)(((ctf_list_t *)(elem))->l_next))
686 extern void ctf_list_append (ctf_list_t
*, void *);
687 extern void ctf_list_prepend (ctf_list_t
*, void *);
688 extern void ctf_list_delete (ctf_list_t
*, void *);
689 extern void ctf_list_splice (ctf_list_t
*, ctf_list_t
*);
690 extern int ctf_list_empty_p (ctf_list_t
*lp
);
692 extern int ctf_dtd_insert (ctf_dict_t
*, ctf_dtdef_t
*, int flag
, int kind
);
693 extern void ctf_dtd_delete (ctf_dict_t
*, ctf_dtdef_t
*);
694 extern ctf_dtdef_t
*ctf_dtd_lookup (const ctf_dict_t
*, ctf_id_t
);
695 extern ctf_dtdef_t
*ctf_dynamic_type (const ctf_dict_t
*, ctf_id_t
);
697 extern int ctf_dvd_insert (ctf_dict_t
*, ctf_dvdef_t
*);
698 extern void ctf_dvd_delete (ctf_dict_t
*, ctf_dvdef_t
*);
699 extern ctf_dvdef_t
*ctf_dvd_lookup (const ctf_dict_t
*, const char *);
701 extern ctf_id_t
ctf_add_encoded (ctf_dict_t
*, uint32_t, const char *,
702 const ctf_encoding_t
*, uint32_t kind
);
703 extern ctf_id_t
ctf_add_reftype (ctf_dict_t
*, uint32_t, ctf_id_t
,
706 extern void ctf_add_type_mapping (ctf_dict_t
*src_fp
, ctf_id_t src_type
,
707 ctf_dict_t
*dst_fp
, ctf_id_t dst_type
);
708 extern ctf_id_t
ctf_type_mapping (ctf_dict_t
*src_fp
, ctf_id_t src_type
,
709 ctf_dict_t
**dst_fp
);
711 extern int ctf_dedup_atoms_init (ctf_dict_t
*);
712 extern int ctf_dedup (ctf_dict_t
*, ctf_dict_t
**, uint32_t ninputs
,
713 uint32_t *parents
, int cu_mapped
);
714 extern void ctf_dedup_fini (ctf_dict_t
*, ctf_dict_t
**, uint32_t);
715 extern ctf_dict_t
**ctf_dedup_emit (ctf_dict_t
*, ctf_dict_t
**,
716 uint32_t ninputs
, uint32_t *parents
,
717 uint32_t *noutputs
, int cu_mapped
);
719 extern void ctf_decl_init (ctf_decl_t
*);
720 extern void ctf_decl_fini (ctf_decl_t
*);
721 extern void ctf_decl_push (ctf_decl_t
*, ctf_dict_t
*, ctf_id_t
);
723 _libctf_printflike_ (2, 3)
724 extern void ctf_decl_sprintf (ctf_decl_t
*, const char *, ...);
725 extern char *ctf_decl_buf (ctf_decl_t
*cd
);
727 extern const char *ctf_strptr (ctf_dict_t
*, uint32_t);
728 extern const char *ctf_strraw (ctf_dict_t
*, uint32_t);
729 extern const char *ctf_strraw_explicit (ctf_dict_t
*, uint32_t,
731 extern int ctf_str_create_atoms (ctf_dict_t
*);
732 extern void ctf_str_free_atoms (ctf_dict_t
*);
733 extern uint32_t ctf_str_add (ctf_dict_t
*, const char *);
734 extern uint32_t ctf_str_add_ref (ctf_dict_t
*, const char *, uint32_t *ref
);
735 extern int ctf_str_add_external (ctf_dict_t
*, const char *, uint32_t offset
);
736 extern void ctf_str_remove_ref (ctf_dict_t
*, const char *, uint32_t *ref
);
737 extern void ctf_str_rollback (ctf_dict_t
*, ctf_snapshot_id_t
);
738 extern void ctf_str_purge_refs (ctf_dict_t
*);
739 extern ctf_strs_writable_t
ctf_str_write_strtab (ctf_dict_t
*);
741 extern struct ctf_archive_internal
*
742 ctf_new_archive_internal (int is_archive
, int unmap_on_close
,
743 struct ctf_archive
*, ctf_dict_t
*,
744 const ctf_sect_t
*symsect
,
745 const ctf_sect_t
*strsect
, int *errp
);
746 extern struct ctf_archive
*ctf_arc_open_internal (const char *, int *);
747 extern void ctf_arc_close_internal (struct ctf_archive
*);
748 extern const ctf_preamble_t
*ctf_arc_bufpreamble (const ctf_sect_t
*);
749 extern void *ctf_set_open_errno (int *, int);
750 extern unsigned long ctf_set_errno (ctf_dict_t
*, int);
752 extern ctf_dict_t
*ctf_simple_open_internal (const char *, size_t, const char *,
754 const char *, size_t,
755 ctf_dynhash_t
*, int, int *);
756 extern ctf_dict_t
*ctf_bufopen_internal (const ctf_sect_t
*, const ctf_sect_t
*,
757 const ctf_sect_t
*, ctf_dynhash_t
*,
759 extern int ctf_import_unref (ctf_dict_t
*fp
, ctf_dict_t
*pfp
);
760 extern int ctf_serialize (ctf_dict_t
*);
763 extern void *ctf_mmap (size_t length
, size_t offset
, int fd
);
764 extern void ctf_munmap (void *, size_t);
765 extern ssize_t
ctf_pread (int fd
, void *buf
, ssize_t count
, off_t offset
);
767 extern void *ctf_realloc (ctf_dict_t
*, void *, size_t);
768 extern char *ctf_str_append (char *, const char *);
769 extern char *ctf_str_append_noerr (char *, const char *);
771 extern ctf_id_t
ctf_type_resolve_unsliced (ctf_dict_t
*, ctf_id_t
);
772 extern int ctf_type_kind_unsliced (ctf_dict_t
*, ctf_id_t
);
774 _libctf_printflike_ (1, 2)
775 extern void ctf_dprintf (const char *, ...);
776 extern void libctf_init_debug (void);
778 _libctf_printflike_ (4, 5)
779 extern void ctf_err_warn (ctf_dict_t
*, int is_warning
, int err
,
781 extern void ctf_err_warn_to_open (ctf_dict_t
*);
782 extern void ctf_assert_fail_internal (ctf_dict_t
*, const char *,
783 size_t, const char *);
784 extern const char *ctf_link_input_name (ctf_dict_t
*);
786 extern ctf_link_sym_t
*ctf_elf32_to_link_sym (ctf_dict_t
*fp
, ctf_link_sym_t
*dst
,
787 const Elf32_Sym
*src
, uint32_t symidx
);
788 extern ctf_link_sym_t
*ctf_elf64_to_link_sym (ctf_dict_t
*fp
, ctf_link_sym_t
*dst
,
789 const Elf64_Sym
*src
, uint32_t symidx
);
791 /* Variables, all underscore-prepended. */
793 extern const char _CTF_SECTION
[]; /* name of CTF ELF section */
794 extern const char _CTF_NULLSTR
[]; /* empty string */
796 extern int _libctf_version
; /* library client version */
797 extern int _libctf_debug
; /* debugging messages enabled */
799 #include "ctf-inlines.h"
805 #endif /* _CTF_IMPL_H */