1 /* Implementation header. 2 Copyright (C) 2019-2024 Free Software Foundation, Inc. 3 4 This file is part of libctf. 5 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 9 version. 10 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. 15 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/>. */ 19 20 #ifndef _CTF_IMPL_H 21 #define _CTF_IMPL_H 22 23 #include "config.h" 24 #include <errno.h> 25 #include <sys/param.h> 26 #include "ctf-decls.h" 27 #include <ctf-api.h> 28 #include "ctf-sha1.h" 29 #include <sys/types.h> 30 #include <stdlib.h> 31 #include <stdarg.h> 32 #include <stddef.h> 33 #include <stdio.h> 34 #include <stdint.h> 35 #include <string.h> 36 #include <limits.h> 37 #include <ctype.h> 38 #include <elf.h> 39 #include <bfd.h> 40 #include "hashtab.h" 41 #include "ctf-intl.h" 42 43 #ifdef __cplusplus 44 extern "C" 45 { 46 #endif 47 48 /* Tuning. */ 49 50 /* The proportion of symtypetab entries which must be pads before we consider it 51 worthwhile to emit a symtypetab section as an index. Indexes cost time to 52 look up, but save space all told. Do not set to 1, since this will cause 53 indexes to be eschewed completely, even in child dicts, at considerable space 54 cost. */ 55 #define CTF_INDEX_PAD_THRESHOLD .75 56 57 /* Compiler attributes. */ 58 59 #if defined (__GNUC__) 60 61 /* GCC. We assume that all compilers claiming to be GCC support sufficiently 62 many GCC attributes that the code below works. If some non-GCC compilers 63 masquerading as GCC in fact do not implement these attributes, version checks 64 may be required. */ 65 66 /* We use the _libctf_*_ pattern to avoid clashes with any future attribute 67 macros glibc may introduce, which have names of the pattern 68 __attribute_blah__. */ 69 70 #define _libctf_printflike_(string_index,first_to_check) \ 71 __attribute__ ((__format__ (__printf__, (string_index), (first_to_check)))) 72 #define _libctf_unlikely_(x) __builtin_expect ((x), 0) 73 #define _libctf_unused_ __attribute__ ((__unused__)) 74 #define _libctf_malloc_ __attribute__((__malloc__)) 75 #define _libctf_nonnull_(params) __attribute__((__nonnull__ params)) 76 77 #else 78 79 #define _libctf_printflike_(string_index,first_to_check) 80 #define _libctf_unlikely_(x) (x) 81 #define _libctf_unused_ 82 #define _libctf_malloc_ 83 #define _libctf_nonnull_(params) 84 #define __extension__ 85 86 #endif 87 88 #if defined (ENABLE_LIBCTF_HASH_DEBUGGING) && !defined (NDEBUG) 89 #include <assert.h> 90 #define ctf_assert(fp, expr) (assert (expr), 1) 91 #else 92 #define ctf_assert(fp, expr) \ 93 _libctf_unlikely_ (ctf_assert_internal (fp, __FILE__, __LINE__, \ 94 #expr, !!(expr))) 95 #endif 96 97 /* libctf in-memory state. */ 98 99 typedef struct ctf_fixed_hash ctf_hash_t; /* Private to ctf-hash.c. */ 100 typedef struct ctf_dynhash ctf_dynhash_t; /* Private to ctf-hash.c. */ 101 typedef struct ctf_dynset ctf_dynset_t; /* Private to ctf-hash.c. */ 102 103 typedef struct ctf_strs 104 { 105 const char *cts_strs; /* Base address of string table. */ 106 size_t cts_len; /* Size of string table in bytes. */ 107 } ctf_strs_t; 108 109 typedef struct ctf_strs_writable 110 { 111 char *cts_strs; /* Base address of string table. */ 112 size_t cts_len; /* Size of string table in bytes. */ 113 } ctf_strs_writable_t; 114 115 typedef struct ctf_dmodel 116 { 117 const char *ctd_name; /* Data model name. */ 118 int ctd_code; /* Data model code. */ 119 size_t ctd_pointer; /* Size of void * in bytes. */ 120 size_t ctd_char; /* Size of char in bytes. */ 121 size_t ctd_short; /* Size of short in bytes. */ 122 size_t ctd_int; /* Size of int in bytes. */ 123 size_t ctd_long; /* Size of long in bytes. */ 124 } ctf_dmodel_t; 125 126 typedef struct ctf_lookup 127 { 128 const char *ctl_prefix; /* String prefix for this lookup. */ 129 size_t ctl_len; /* Length of prefix string in bytes. */ 130 ctf_dynhash_t *ctl_hash; /* Pointer to hash table for lookup. */ 131 } ctf_lookup_t; 132 133 typedef struct ctf_dictops 134 { 135 uint32_t (*ctfo_get_kind) (uint32_t); 136 uint32_t (*ctfo_get_root) (uint32_t); 137 uint32_t (*ctfo_get_vlen) (uint32_t); 138 ssize_t (*ctfo_get_ctt_size) (const ctf_dict_t *, const ctf_type_t *, 139 ssize_t *, ssize_t *); 140 ssize_t (*ctfo_get_vbytes) (ctf_dict_t *, unsigned short, ssize_t, size_t); 141 } ctf_dictops_t; 142 143 typedef struct ctf_list 144 { 145 struct ctf_list *l_prev; /* Previous pointer or tail pointer. */ 146 struct ctf_list *l_next; /* Next pointer or head pointer. */ 147 } ctf_list_t; 148 149 typedef enum 150 { 151 CTF_PREC_BASE, 152 CTF_PREC_POINTER, 153 CTF_PREC_ARRAY, 154 CTF_PREC_FUNCTION, 155 CTF_PREC_MAX 156 } ctf_decl_prec_t; 157 158 typedef struct ctf_decl_node 159 { 160 ctf_list_t cd_list; /* Linked list pointers. */ 161 ctf_id_t cd_type; /* Type identifier. */ 162 uint32_t cd_kind; /* Type kind. */ 163 uint32_t cd_n; /* Type dimension if array. */ 164 } ctf_decl_node_t; 165 166 typedef struct ctf_decl 167 { 168 ctf_list_t cd_nodes[CTF_PREC_MAX]; /* Declaration node stacks. */ 169 int cd_order[CTF_PREC_MAX]; /* Storage order of decls. */ 170 ctf_decl_prec_t cd_qualp; /* Qualifier precision. */ 171 ctf_decl_prec_t cd_ordp; /* Ordered precision. */ 172 char *cd_buf; /* Buffer for output. */ 173 int cd_err; /* Saved error value. */ 174 int cd_enomem; /* Nonzero if OOM during printing. */ 175 } ctf_decl_t; 176 177 typedef struct ctf_dtdef 178 { 179 ctf_list_t dtd_list; /* List forward/back pointers. */ 180 ctf_id_t dtd_type; /* Type identifier for this definition. */ 181 ctf_type_t dtd_data; /* Type node, including name. */ 182 size_t dtd_vlen_alloc; /* Total vlen space allocated. */ 183 unsigned char *dtd_vlen; /* Variable-length data for this type. */ 184 } ctf_dtdef_t; 185 186 typedef struct ctf_dvdef 187 { 188 ctf_list_t dvd_list; /* List forward/back pointers. */ 189 char *dvd_name; /* Name associated with variable. */ 190 ctf_id_t dvd_type; /* Type of variable. */ 191 unsigned long dvd_snapshots; /* Snapshot count when inserted. */ 192 } ctf_dvdef_t; 193 194 typedef struct ctf_err_warning 195 { 196 ctf_list_t cew_list; /* List forward/back pointers. */ 197 int cew_is_warning; /* 1 if warning, 0 if error. */ 198 char *cew_text; /* Error/warning text. */ 199 } ctf_err_warning_t; 200 201 /* Atoms associate strings with a list of the CTF items that reference that 202 string, so that ctf_serialize() can instantiate all the strings using the 203 ctf_str_atoms and then reassociate them with the real string later. 204 205 Strings can be interned into ctf_str_atom without having refs associated 206 with them, for values that are returned to callers, etc. Items are only 207 removed from this table on ctf_close(), but on every ctf_serialize(), all 208 the csa_refs in all entries are purged. */ 209 210 #define CTF_STR_ATOM_FREEABLE 0x1 211 #define CTF_STR_ATOM_MOVABLE 0x2 212 213 typedef struct ctf_str_atom 214 { 215 char *csa_str; /* Pointer to string (also used as hash key). */ 216 ctf_list_t csa_refs; /* This string's refs. */ 217 uint32_t csa_offset; /* Strtab offset, if any. */ 218 uint32_t csa_external_offset; /* External strtab offset, if any. */ 219 unsigned long csa_snapshot_id; /* Snapshot ID at time of creation. */ 220 int csa_flags; /* CTF_STR_ATOM_* flags. */ 221 } ctf_str_atom_t; 222 223 /* The refs of a single string in the atoms table. */ 224 225 typedef struct ctf_str_atom_ref 226 { 227 ctf_list_t caf_list; /* List forward/back pointers. */ 228 uint32_t *caf_ref; /* A single ref to this string. */ 229 } ctf_str_atom_ref_t; 230 231 /* Like a ctf_str_atom_ref_t, but specific to movable refs. */ 232 233 typedef struct ctf_str_atom_ref_movable 234 { 235 ctf_list_t caf_list; /* List forward/back pointers. */ 236 uint32_t *caf_ref; /* A single ref to this string. */ 237 ctf_dynhash_t *caf_movable_refs; /* Backpointer to ctf_str_movable_refs for this dict. */ 238 } ctf_str_atom_ref_movable_t; 239 240 /* A single linker-provided symbol, during symbol addition, possibly before we 241 have been given external strtab refs. */ 242 typedef struct ctf_in_flight_dynsym 243 { 244 ctf_list_t cid_list; /* List forward/back pointers. */ 245 ctf_link_sym_t cid_sym; /* The linker-known symbol. */ 246 } ctf_in_flight_dynsym_t; 247 248 /* The structure used as the key in a ctf_link_type_mapping. The value is a 249 type index, not a type ID. */ 250 251 typedef struct ctf_link_type_key 252 { 253 ctf_dict_t *cltk_fp; 254 ctf_id_t cltk_idx; 255 } ctf_link_type_key_t; 256 257 /* The structure used as the key in a cd_id_to_dict_t on 32-bit platforms. */ 258 typedef struct ctf_type_id_key 259 { 260 int ctii_input_num; 261 ctf_id_t ctii_type; 262 } ctf_type_id_key_t; 263 264 /* Deduplicator state. 265 266 The dedup state below uses three terms consistently. A "hash" is a 267 ctf_dynhash_t; a "hash value" is the hash value of a type as returned by 268 ctf_dedup_hash_type; a "global type ID" or "global ID" is a packed-together 269 reference to a single ctf_dict_t (by array index in an array of inputs) and 270 ctf_id_t, i.e. a single instance of some hash value in some input. 271 272 The deduplication algorithm takes a bunch of inputs and yields a single 273 shared "output" and possibly many outputs corresponding to individual inputs 274 that still contain types after sharing of unconflicted types. Almost all 275 deduplicator state is stored in the struct ctf_dedup in the output, though a 276 (very) few things are stored in inputs for simplicity's sake, usually if they 277 are linking together things within the scope of a single TU. 278 279 Flushed at the end of every ctf_dedup run. */ 280 281 typedef struct ctf_dedup 282 { 283 /* The CTF linker flags in force for this dedup run. */ 284 int cd_link_flags; 285 286 /* On 32-bit platforms only, a hash of global type IDs, in the form of 287 a ctf_link_type_id_key_t. */ 288 ctf_dynhash_t *cd_id_to_dict_t; 289 290 /* Atoms tables of decorated names: maps undecorated name to decorated name. 291 (The actual allocations are in the CTF dict for the former and the real 292 atoms table for the latter). Uses the same namespaces as ctf_lookups, 293 below, but has no need for null-termination. */ 294 ctf_dynhash_t *cd_decorated_names[4]; 295 296 /* Map type names to a hash from type hash value -> number of times each value 297 has appeared. */ 298 ctf_dynhash_t *cd_name_counts; 299 300 /* Map global type IDs to type hash values. Used to determine if types are 301 already hashed without having to recompute their hash values again, and to 302 link types together at later stages. Forwards that are peeked through to 303 structs and unions are not represented in here, so lookups that might be 304 such a type (in practice, all lookups) must go via cd_replaced_types first 305 to take this into account. Discarded before each rehashing. */ 306 ctf_dynhash_t *cd_type_hashes; 307 308 /* Maps from the names of structs/unions/enums to a a single GID which is the 309 only appearance of that type in any input: if it appears in more than one 310 input, a value which is a GID with an input_num of -1 appears. Used in 311 share-duplicated link mode link modes to determine whether structs/unions 312 can be cited from multiple TUs. Only populated in that link mode. */ 313 ctf_dynhash_t *cd_struct_origin; 314 315 /* Maps type hash values to a set of hash values of the types that cite them: 316 i.e., pointing backwards up the type graph. Used for recursive conflict 317 marking. Citations from tagged structures, unions, and forwards do not 318 appear in this graph. */ 319 ctf_dynhash_t *cd_citers; 320 321 /* Maps type hash values to input global type IDs. The value is a set (a 322 hash) of global type IDs. Discarded before each rehashing. The result of 323 the ctf_dedup function. */ 324 ctf_dynhash_t *cd_output_mapping; 325 326 /* A map giving the GID of the first appearance of each type for each type 327 hash value. */ 328 ctf_dynhash_t *cd_output_first_gid; 329 330 /* Used to ensure that we never try to map a single type ID to more than one 331 hash. */ 332 ctf_dynhash_t *cd_output_mapping_guard; 333 334 /* Maps the global type IDs of structures in input TUs whose members still 335 need emission to the global type ID of the already-emitted target type 336 (which has no members yet) in the appropriate target. Uniquely, the latter 337 ID represents a *target* ID (i.e. the cd_output_mapping of some specified 338 input): we encode the shared (parent) dict with an ID of -1. */ 339 ctf_dynhash_t *cd_emission_struct_members; 340 341 /* A set (a hash) of hash values of conflicting types. */ 342 ctf_dynset_t *cd_conflicting_types; 343 344 /* A hash mapping fp *'s of inputs to their input_nums. Used only by 345 functions outside the core ctf_dedup / ctf_dedup_emit machinery which do 346 not take an inputs array. */ 347 ctf_dynhash_t *cd_input_nums; 348 349 /* Maps type hashes to ctf_id_t's in this dictionary. Populated only at 350 emission time, in the dictionary where emission is taking place. */ 351 ctf_dynhash_t *cd_output_emission_hashes; 352 353 /* Maps the decorated names of conflicted cross-TU forwards that were forcibly 354 emitted in this TU to their emitted ctf_id_ts. Populated only at emission 355 time, in the dictionary where emission is taking place. */ 356 ctf_dynhash_t *cd_output_emission_conflicted_forwards; 357 358 /* Points to the output counterpart of this input dictionary, at emission 359 time. */ 360 ctf_dict_t *cd_output; 361 } ctf_dedup_t; 362 363 /* The ctf_dict is the structure used to represent a CTF dictionary to library 364 clients, who see it only as an opaque pointer. Modifications can therefore 365 be made freely to this structure without regard to client versioning. The 366 ctf_dict_t typedef appears in <ctf-api.h> and declares a forward tag. 367 (A ctf_file_t typedef also appears there, for historical reasons.) */ 368 369 struct ctf_dict 370 { 371 const ctf_dictops_t *ctf_dictops; /* Version-specific dict operations. */ 372 struct ctf_header *ctf_header; /* The header from this CTF dict. */ 373 unsigned char ctf_openflags; /* Flags the dict had when opened. */ 374 ctf_sect_t ctf_data; /* CTF data from object file. */ 375 ctf_sect_t ctf_ext_symtab; /* Symbol table from object file. */ 376 ctf_sect_t ctf_ext_strtab; /* String table from object file. */ 377 int ctf_symsect_little_endian; /* Endianness of the ctf_ext_symtab. */ 378 ctf_dynhash_t *ctf_symhash_func; /* (partial) hash, symsect name -> idx. */ 379 ctf_dynhash_t *ctf_symhash_objt; /* ditto, for object symbols. */ 380 size_t ctf_symhash_latest; /* Amount of symsect scanned so far. */ 381 ctf_dynhash_t *ctf_prov_strtab; /* Maps provisional-strtab offsets 382 to names. */ 383 ctf_dynhash_t *ctf_syn_ext_strtab; /* Maps ext-strtab offsets to names. */ 384 void *ctf_data_mmapped; /* CTF data we mmapped, to free later. */ 385 size_t ctf_data_mmapped_len; /* Length of CTF data we mmapped. */ 386 ctf_dynhash_t *ctf_structs; /* Hash table of struct types. */ 387 ctf_dynhash_t *ctf_unions; /* Hash table of union types. */ 388 ctf_dynhash_t *ctf_enums; /* Hash table of enum types. */ 389 ctf_dynhash_t *ctf_names; /* Hash table of remaining type names. */ 390 ctf_lookup_t ctf_lookups[5]; /* Pointers to nametabs for name lookup. */ 391 ctf_strs_t ctf_str[2]; /* Array of string table base and bounds. */ 392 ctf_strs_writable_t *ctf_dynstrtab; /* Dynamically allocated string table, if any. */ 393 ctf_dynhash_t *ctf_str_atoms; /* Hash table of ctf_str_atoms_t. */ 394 ctf_dynhash_t *ctf_str_movable_refs; /* Hash table of void * -> ctf_str_atom_ref_t. */ 395 uint32_t ctf_str_prov_offset; /* Latest provisional offset assigned so far. */ 396 unsigned char *ctf_base; /* CTF file pointer. */ 397 unsigned char *ctf_dynbase; /* Freeable CTF file pointer. */ 398 unsigned char *ctf_buf; /* Uncompressed CTF data buffer. */ 399 size_t ctf_size; /* Size of CTF header + uncompressed data. */ 400 uint32_t *ctf_sxlate; /* Translation table for unindexed symtypetab 401 entries. */ 402 unsigned long ctf_nsyms; /* Number of entries in symtab xlate table. */ 403 uint32_t *ctf_txlate; /* Translation table for type IDs. */ 404 uint32_t *ctf_ptrtab; /* Translation table for pointer-to lookups. */ 405 size_t ctf_ptrtab_len; /* Num types storable in ptrtab currently. */ 406 uint32_t *ctf_pptrtab; /* Parent types pointed to by child dicts. */ 407 size_t ctf_pptrtab_len; /* Num types storable in pptrtab currently. */ 408 uint32_t ctf_pptrtab_typemax; /* Max child type when pptrtab last updated. */ 409 uint32_t *ctf_funcidx_names; /* Name of each function symbol in symtypetab 410 (if indexed). */ 411 uint32_t *ctf_objtidx_names; /* Likewise, for object symbols. */ 412 size_t ctf_nfuncidx; /* Number of funcidx entries. */ 413 uint32_t *ctf_funcidx_sxlate; /* Offsets into funcinfo for a given funcidx. */ 414 uint32_t *ctf_objtidx_sxlate; /* Likewise, for ctf_objtidx. */ 415 size_t ctf_nobjtidx; /* Number of objtidx entries. */ 416 ctf_dynhash_t *ctf_objthash; /* Dynamic: name -> type ID. */ 417 ctf_dynhash_t *ctf_funchash; /* Dynamic: name -> CTF_K_FUNCTION type ID. */ 418 419 /* The next three are linker-derived state found in ctf_link targets only. */ 420 421 ctf_dynhash_t *ctf_dynsyms; /* Symbol info from ctf_link_shuffle_syms. */ 422 ctf_link_sym_t **ctf_dynsymidx; /* Indexes ctf_dynsyms by symidx. */ 423 uint32_t ctf_dynsymmax; /* Maximum ctf_dynsym index. */ 424 ctf_list_t ctf_in_flight_dynsyms; /* Dynsyms during accumulation. */ 425 struct ctf_varent *ctf_vars; /* Sorted variable->type mapping. */ 426 unsigned long ctf_nvars; /* Number of variables in ctf_vars. */ 427 unsigned long ctf_typemax; /* Maximum valid type ID number. */ 428 unsigned long ctf_stypes; /* Number of static (non-dynamic) types. */ 429 const ctf_dmodel_t *ctf_dmodel; /* Data model pointer (see above). */ 430 const char *ctf_cuname; /* Compilation unit name (if any). */ 431 char *ctf_dyncuname; /* Dynamically allocated name of CU. */ 432 struct ctf_dict *ctf_parent; /* Parent CTF dict (if any). */ 433 int ctf_parent_unreffed; /* Parent set by ctf_import_unref? */ 434 const char *ctf_parlabel; /* Label in parent dict (if any). */ 435 const char *ctf_parname; /* Basename of parent (if any). */ 436 char *ctf_dynparname; /* Dynamically allocated name of parent. */ 437 uint32_t ctf_parmax; /* Highest type ID of a parent type. */ 438 uint32_t ctf_refcnt; /* Reference count (for parent links). */ 439 uint32_t ctf_flags; /* Libctf flags (see below). */ 440 int ctf_errno; /* Error code for most recent error. */ 441 int ctf_version; /* CTF data version. */ 442 ctf_dynhash_t *ctf_dthash; /* Hash of dynamic type definitions. */ 443 ctf_list_t ctf_dtdefs; /* List of dynamic type definitions. */ 444 ctf_dynhash_t *ctf_dvhash; /* Hash of dynamic variable mappings. */ 445 ctf_list_t ctf_dvdefs; /* List of dynamic variable definitions. */ 446 unsigned long ctf_dtoldid; /* Oldest id that has been committed. */ 447 unsigned long ctf_snapshots; /* ctf_snapshot() plus ctf_update() count. */ 448 unsigned long ctf_snapshot_lu; /* ctf_snapshot() call count at last update. */ 449 ctf_archive_t *ctf_archive; /* Archive this ctf_dict_t came from. */ 450 ctf_list_t ctf_errs_warnings; /* CTF errors and warnings. */ 451 ctf_dynhash_t *ctf_link_inputs; /* Inputs to this link. */ 452 ctf_dynhash_t *ctf_link_outputs; /* Additional outputs from this link. */ 453 454 /* If a link input CU, points at the corresponding per-CU output (if any); 455 if an output, points at the input (if any). */ 456 ctf_dict_t *ctf_link_in_out; 457 458 /* Map input types to output types for ctf_add_type. Key is a 459 ctf_link_type_key_t: value is a type ID. */ 460 ctf_dynhash_t *ctf_link_type_mapping; 461 462 /* Map input CU names to output CTF dict names: populated in the top-level 463 output dict. 464 465 Key and value are dynamically-allocated strings. */ 466 ctf_dynhash_t *ctf_link_in_cu_mapping; 467 468 /* Map output CTF dict names to input CU names: populated in the top-level 469 output dict. A hash of string to hash (set) of strings. Key and 470 individual value members are shared with ctf_link_in_cu_mapping. */ 471 ctf_dynhash_t *ctf_link_out_cu_mapping; 472 473 /* CTF linker flags. Set on the parent output dict (the one passed to 474 ctf_link). Only respected when LCTF_LINKING set in ctf_flags. */ 475 int ctf_link_flags; 476 477 /* Allow the caller to change the name of link archive members. */ 478 ctf_link_memb_name_changer_f *ctf_link_memb_name_changer; 479 void *ctf_link_memb_name_changer_arg; /* Argument for it. */ 480 481 /* Allow the caller to filter out variables they don't care about. */ 482 ctf_link_variable_filter_f *ctf_link_variable_filter; 483 void *ctf_link_variable_filter_arg; /* Argument for it. */ 484 485 ctf_dynhash_t *ctf_add_processing; /* Types ctf_add_type is working on now. */ 486 487 /* Atoms table for dedup string storage. All strings in the ctf_dedup_t are 488 stored here. Only the _alloc copy is allocated or freed: the 489 ctf_dedup_atoms may be pointed to some other CTF dict, to share its atoms. 490 We keep the atoms table outside the ctf_dedup so that atoms can be 491 preserved across multiple similar links, such as when doing cu-mapped 492 links. */ 493 ctf_dynset_t *ctf_dedup_atoms; 494 ctf_dynset_t *ctf_dedup_atoms_alloc; 495 496 ctf_dedup_t ctf_dedup; /* Deduplicator state. */ 497 498 char *ctf_tmp_typeslice; /* Storage for slicing up type names. */ 499 size_t ctf_tmp_typeslicelen; /* Size of the typeslice. */ 500 void *ctf_specific; /* Data for ctf_get/setspecific(). */ 501 }; 502 503 /* An abstraction over both a ctf_dict_t and a ctf_archive_t. */ 504 505 struct ctf_archive_internal 506 { 507 int ctfi_is_archive; 508 int ctfi_unmap_on_close; 509 ctf_dict_t *ctfi_dict; 510 struct ctf_archive *ctfi_archive; 511 ctf_dynhash_t *ctfi_dicts; /* Dicts we have opened and cached. */ 512 ctf_dict_t *ctfi_crossdict_cache; /* Cross-dict caching. */ 513 ctf_dict_t **ctfi_symdicts; /* Array of index -> ctf_dict_t *. */ 514 ctf_dynhash_t *ctfi_symnamedicts; /* Hash of name -> ctf_dict_t *. */ 515 ctf_sect_t ctfi_symsect; 516 int ctfi_symsect_little_endian; /* -1 for unknown / do not set. */ 517 ctf_sect_t ctfi_strsect; 518 int ctfi_free_symsect; 519 int ctfi_free_strsect; 520 void *ctfi_data; 521 bfd *ctfi_abfd; /* Optional source of section data. */ 522 void (*ctfi_bfd_close) (struct ctf_archive_internal *); 523 }; 524 525 /* Iterator state for the *_next() functions. */ 526 527 /* A single hash key/value pair. */ 528 typedef struct ctf_next_hkv 529 { 530 void *hkv_key; 531 void *hkv_value; 532 } ctf_next_hkv_t; 533 534 struct ctf_next 535 { 536 void (*ctn_iter_fun) (void); 537 ctf_id_t ctn_type; 538 ssize_t ctn_size; 539 ssize_t ctn_increment; 540 const ctf_type_t *ctn_tp; 541 uint32_t ctn_n; 542 543 /* Some iterators contain other iterators, in addition to their other 544 state. */ 545 ctf_next_t *ctn_next; 546 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. */ 551 union 552 { 553 unsigned char *ctn_vlen; 554 const ctf_enum_t *ctn_en; 555 const ctf_dvdef_t *ctn_dvd; 556 ctf_next_hkv_t *ctn_sorted_hkv; 557 void **ctn_hash_slot; 558 } u; 559 560 /* This union is of various sorts of dict we can iterate over: 561 currently dictionaries and archives, dynhashes, and dynsets. */ 562 union 563 { 564 const ctf_dict_t *ctn_fp; 565 const ctf_archive_t *ctn_arc; 566 const ctf_dynhash_t *ctn_h; 567 const ctf_dynset_t *ctn_s; 568 } cu; 569 }; 570 571 /* Return x rounded up to an alignment boundary. 572 eg, P2ROUNDUP(0x1234, 0x100) == 0x1300 (0x13*align) 573 eg, P2ROUNDUP(0x5600, 0x100) == 0x5600 (0x56*align) */ 574 #define P2ROUNDUP(x, align) (-(-(x) & -(align))) 575 576 /* * If an offs is not aligned already then round it up and align it. */ 577 #define LCTF_ALIGN_OFFS(offs, align) ((offs + (align - 1)) & ~(align - 1)) 578 579 #define LCTF_TYPE_ISPARENT(fp, id) ((id) <= fp->ctf_parmax) 580 #define LCTF_TYPE_ISCHILD(fp, id) ((id) > fp->ctf_parmax) 581 #define LCTF_TYPE_TO_INDEX(fp, id) ((id) & (fp->ctf_parmax)) 582 #define LCTF_INDEX_TO_TYPE(fp, id, child) (child ? ((id) | (fp->ctf_parmax+1)) : \ 583 (id)) 584 585 #define LCTF_INDEX_TO_TYPEPTR(fp, i) \ 586 ((i > fp->ctf_stypes) ? \ 587 &(ctf_dtd_lookup (fp, LCTF_INDEX_TO_TYPE \ 588 (fp, i, fp->ctf_flags & LCTF_CHILD))->dtd_data) : \ 589 (ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)])) 590 591 #define LCTF_INFO_KIND(fp, info) ((fp)->ctf_dictops->ctfo_get_kind(info)) 592 #define LCTF_INFO_ISROOT(fp, info) ((fp)->ctf_dictops->ctfo_get_root(info)) 593 #define LCTF_INFO_VLEN(fp, info) ((fp)->ctf_dictops->ctfo_get_vlen(info)) 594 #define LCTF_VBYTES(fp, kind, size, vlen) \ 595 ((fp)->ctf_dictops->ctfo_get_vbytes(fp, kind, size, vlen)) 596 597 #define LCTF_CHILD 0x0001 /* CTF dict is a child. */ 598 #define LCTF_LINKING 0x0002 /* CTF link is underway: respect ctf_link_flags. */ 599 600 extern ctf_dynhash_t *ctf_name_table (ctf_dict_t *, int); 601 extern const ctf_type_t *ctf_lookup_by_id (ctf_dict_t **, ctf_id_t); 602 extern ctf_id_t ctf_lookup_variable_here (ctf_dict_t *fp, const char *name); 603 extern ctf_id_t ctf_lookup_by_sym_or_name (ctf_dict_t *, unsigned long symidx, 604 const char *symname, int try_parent, 605 int is_function); 606 extern ctf_id_t ctf_lookup_by_rawname (ctf_dict_t *, int, const char *); 607 extern void ctf_set_ctl_hashes (ctf_dict_t *); 608 extern ctf_id_t ctf_symbol_next_static (ctf_dict_t *, ctf_next_t **, 609 const char **, int); 610 611 extern int ctf_symtab_skippable (ctf_link_sym_t *sym); 612 extern int ctf_add_funcobjt_sym (ctf_dict_t *, int is_function, 613 const char *, ctf_id_t); 614 615 extern ctf_dict_t *ctf_get_dict (ctf_dict_t *fp, ctf_id_t type); 616 617 typedef unsigned int (*ctf_hash_fun) (const void *ptr); 618 extern unsigned int ctf_hash_integer (const void *ptr); 619 extern unsigned int ctf_hash_string (const void *ptr); 620 extern unsigned int ctf_hash_type_key (const void *ptr); 621 extern unsigned int ctf_hash_type_id_key (const void *ptr); 622 623 typedef int (*ctf_hash_eq_fun) (const void *, const void *); 624 extern int ctf_hash_eq_integer (const void *, const void *); 625 extern int ctf_hash_eq_string (const void *, const void *); 626 extern int ctf_hash_eq_type_key (const void *, const void *); 627 extern int ctf_hash_eq_type_id_key (const void *, const void *); 628 629 typedef void (*ctf_hash_free_fun) (void *); 630 631 typedef void (*ctf_hash_iter_f) (void *key, void *value, void *arg); 632 typedef int (*ctf_hash_iter_remove_f) (void *key, void *value, void *arg); 633 typedef int (*ctf_hash_iter_find_f) (void *key, void *value, void *arg); 634 typedef int (*ctf_hash_sort_f) (const ctf_next_hkv_t *, const ctf_next_hkv_t *, 635 void *arg); 636 637 extern ctf_dynhash_t *ctf_dynhash_create (ctf_hash_fun, ctf_hash_eq_fun, 638 ctf_hash_free_fun, ctf_hash_free_fun); 639 extern ctf_dynhash_t *ctf_dynhash_create_sized (unsigned long, ctf_hash_fun, 640 ctf_hash_eq_fun, 641 ctf_hash_free_fun, 642 ctf_hash_free_fun); 643 644 extern int ctf_dynhash_insert (ctf_dynhash_t *, void *, void *); 645 extern void ctf_dynhash_remove (ctf_dynhash_t *, const void *); 646 extern size_t ctf_dynhash_elements (ctf_dynhash_t *); 647 extern void ctf_dynhash_empty (ctf_dynhash_t *); 648 extern int ctf_dynhash_insert_type (ctf_dict_t *, ctf_dynhash_t *, uint32_t, uint32_t); 649 extern ctf_id_t ctf_dynhash_lookup_type (ctf_dynhash_t *, const char *); 650 extern void *ctf_dynhash_lookup (ctf_dynhash_t *, const void *); 651 extern int ctf_dynhash_lookup_kv (ctf_dynhash_t *, const void *key, 652 const void **orig_key, void **value); 653 extern void ctf_dynhash_destroy (ctf_dynhash_t *); 654 extern void ctf_dynhash_iter (ctf_dynhash_t *, ctf_hash_iter_f, void *); 655 extern void ctf_dynhash_iter_remove (ctf_dynhash_t *, ctf_hash_iter_remove_f, 656 void *); 657 extern void *ctf_dynhash_iter_find (ctf_dynhash_t *, ctf_hash_iter_find_f, 658 void *); 659 extern int ctf_dynhash_sort_by_name (const ctf_next_hkv_t *, 660 const ctf_next_hkv_t *, 661 void * _libctf_unused_); 662 extern int ctf_dynhash_next (ctf_dynhash_t *, ctf_next_t **, 663 void **key, void **value); 664 extern int ctf_dynhash_next_sorted (ctf_dynhash_t *, ctf_next_t **, 665 void **key, void **value, ctf_hash_sort_f, 666 void *); 667 668 extern ctf_dynset_t *ctf_dynset_create (htab_hash, htab_eq, ctf_hash_free_fun); 669 extern int ctf_dynset_insert (ctf_dynset_t *, void *); 670 extern void ctf_dynset_remove (ctf_dynset_t *, const void *); 671 extern void ctf_dynset_destroy (ctf_dynset_t *); 672 extern void *ctf_dynset_lookup (ctf_dynset_t *, const void *); 673 extern int ctf_dynset_exists (ctf_dynset_t *, const void *key, 674 const void **orig_key); 675 extern int ctf_dynset_next (ctf_dynset_t *, ctf_next_t **, void **key); 676 extern void *ctf_dynset_lookup_any (ctf_dynset_t *); 677 678 extern void ctf_sha1_init (ctf_sha1_t *); 679 extern void ctf_sha1_add (ctf_sha1_t *, const void *, size_t); 680 extern char *ctf_sha1_fini (ctf_sha1_t *, char *); 681 682 #define ctf_list_prev(elem) ((void *)(((ctf_list_t *)(elem))->l_prev)) 683 #define ctf_list_next(elem) ((void *)(((ctf_list_t *)(elem))->l_next)) 684 685 extern void ctf_list_append (ctf_list_t *, void *); 686 extern void ctf_list_prepend (ctf_list_t *, void *); 687 extern void ctf_list_delete (ctf_list_t *, void *); 688 extern void ctf_list_splice (ctf_list_t *, ctf_list_t *); 689 extern int ctf_list_empty_p (ctf_list_t *lp); 690 691 extern int ctf_dtd_insert (ctf_dict_t *, ctf_dtdef_t *, int flag, int kind); 692 extern void ctf_dtd_delete (ctf_dict_t *, ctf_dtdef_t *); 693 extern ctf_dtdef_t *ctf_dtd_lookup (const ctf_dict_t *, ctf_id_t); 694 extern ctf_dtdef_t *ctf_dynamic_type (const ctf_dict_t *, ctf_id_t); 695 696 extern int ctf_dvd_insert (ctf_dict_t *, ctf_dvdef_t *); 697 extern void ctf_dvd_delete (ctf_dict_t *, ctf_dvdef_t *); 698 extern ctf_dvdef_t *ctf_dvd_lookup (const ctf_dict_t *, const char *); 699 700 extern ctf_id_t ctf_add_encoded (ctf_dict_t *, uint32_t, const char *, 701 const ctf_encoding_t *, uint32_t kind); 702 extern ctf_id_t ctf_add_reftype (ctf_dict_t *, uint32_t, ctf_id_t, 703 uint32_t kind); 704 extern int ctf_add_variable_forced (ctf_dict_t *, const char *, ctf_id_t); 705 extern int ctf_add_funcobjt_sym_forced (ctf_dict_t *, int is_function, 706 const char *, ctf_id_t); 707 708 extern int ctf_dedup_atoms_init (ctf_dict_t *); 709 extern int ctf_dedup (ctf_dict_t *, ctf_dict_t **, uint32_t ninputs, 710 uint32_t *parents, int cu_mapped); 711 extern void ctf_dedup_fini (ctf_dict_t *, ctf_dict_t **, uint32_t); 712 extern ctf_dict_t **ctf_dedup_emit (ctf_dict_t *, ctf_dict_t **, 713 uint32_t ninputs, uint32_t *parents, 714 uint32_t *noutputs, int cu_mapped); 715 extern ctf_id_t ctf_dedup_type_mapping (ctf_dict_t *fp, ctf_dict_t *src_fp, 716 ctf_id_t src_type); 717 718 extern void ctf_decl_init (ctf_decl_t *); 719 extern void ctf_decl_fini (ctf_decl_t *); 720 extern void ctf_decl_push (ctf_decl_t *, ctf_dict_t *, ctf_id_t); 721 722 _libctf_printflike_ (2, 3) 723 extern void ctf_decl_sprintf (ctf_decl_t *, const char *, ...); 724 extern char *ctf_decl_buf (ctf_decl_t *cd); 725 726 extern const char *ctf_strptr (ctf_dict_t *, uint32_t); 727 extern const char *ctf_strraw (ctf_dict_t *, uint32_t); 728 extern const char *ctf_strraw_explicit (ctf_dict_t *, uint32_t, 729 ctf_strs_t *); 730 extern const char *ctf_strptr_validate (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 uint32_t ctf_str_add_movable_ref (ctf_dict_t *, const char *, 736 uint32_t *ref); 737 extern int ctf_str_move_refs (ctf_dict_t *fp, void *src, size_t len, void *dest); 738 extern int ctf_str_add_external (ctf_dict_t *, const char *, uint32_t offset); 739 extern void ctf_str_remove_ref (ctf_dict_t *, const char *, uint32_t *ref); 740 extern void ctf_str_rollback (ctf_dict_t *, ctf_snapshot_id_t); 741 extern void ctf_str_purge_refs (ctf_dict_t *); 742 extern const ctf_strs_writable_t *ctf_str_write_strtab (ctf_dict_t *); 743 744 extern struct ctf_archive_internal * 745 ctf_new_archive_internal (int is_archive, int unmap_on_close, 746 struct ctf_archive *, ctf_dict_t *, 747 const ctf_sect_t *symsect, 748 const ctf_sect_t *strsect, int *errp); 749 extern struct ctf_archive *ctf_arc_open_internal (const char *, int *); 750 extern void ctf_arc_close_internal (struct ctf_archive *); 751 extern const ctf_preamble_t *ctf_arc_bufpreamble (const ctf_sect_t *); 752 extern void *ctf_set_open_errno (int *, int); 753 extern void ctf_flip_header (ctf_header_t *); 754 extern int ctf_flip (ctf_dict_t *, ctf_header_t *, unsigned char *, int); 755 756 extern int ctf_import_unref (ctf_dict_t *fp, ctf_dict_t *pfp); 757 758 _libctf_malloc_ 759 extern void *ctf_mmap (size_t length, size_t offset, int fd); 760 extern void ctf_munmap (void *, size_t); 761 extern ssize_t ctf_pread (int fd, void *buf, ssize_t count, off_t offset); 762 763 extern char *ctf_str_append (char *, const char *); 764 extern char *ctf_str_append_noerr (char *, const char *); 765 766 extern ctf_id_t ctf_type_resolve_unsliced (ctf_dict_t *, ctf_id_t); 767 extern int ctf_type_kind_unsliced (ctf_dict_t *, ctf_id_t); 768 769 _libctf_printflike_ (1, 2) 770 extern void ctf_dprintf (const char *, ...); 771 extern void libctf_init_debug (void); 772 773 _libctf_printflike_ (4, 5) 774 extern void ctf_err_warn (ctf_dict_t *, int is_warning, int err, 775 const char *, ...); 776 extern void ctf_err_warn_to_open (ctf_dict_t *); 777 extern void ctf_assert_fail_internal (ctf_dict_t *, const char *, 778 size_t, const char *); 779 extern const char *ctf_link_input_name (ctf_dict_t *); 780 781 extern ctf_link_sym_t *ctf_elf32_to_link_sym (ctf_dict_t *fp, ctf_link_sym_t *dst, 782 const Elf32_Sym *src, uint32_t symidx); 783 extern ctf_link_sym_t *ctf_elf64_to_link_sym (ctf_dict_t *fp, ctf_link_sym_t *dst, 784 const Elf64_Sym *src, uint32_t symidx); 785 786 /* Variables, all underscore-prepended. */ 787 788 extern const char _CTF_SECTION[]; /* name of CTF ELF section */ 789 extern const char _CTF_NULLSTR[]; /* empty string */ 790 791 extern int _libctf_version; /* library client version */ 792 extern int _libctf_debug; /* debugging messages enabled */ 793 794 #include "ctf-inlines.h" 795 796 #ifdef __cplusplus 797 } 798 #endif 799 800 #endif /* _CTF_IMPL_H */ 801