152284Sobrien/* Implementation header. 252284Sobrien Copyright (C) 2019-2022 Free Software Foundation, Inc. 352284Sobrien 490075Sobrien This file is part of libctf. 552284Sobrien 652284Sobrien libctf is free software; you can redistribute it and/or modify it under 790075Sobrien the terms of the GNU General Public License as published by the Free 852284Sobrien Software Foundation; either version 3, or (at your option) any later 990075Sobrien version. 1090075Sobrien 1152284Sobrien This program is distributed in the hope that it will be useful, but 1290075Sobrien WITHOUT ANY WARRANTY; without even the implied warranty of 1390075Sobrien MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 1490075Sobrien See the GNU General Public License for more details. 1590075Sobrien 1690075Sobrien You should have received a copy of the GNU General Public License 1752284Sobrien along with this program; see the file COPYING. If not see 1890075Sobrien <http://www.gnu.org/licenses/>. */ 1990075Sobrien 2090075Sobrien#ifndef _CTF_IMPL_H 2190075Sobrien#define _CTF_IMPL_H 2290075Sobrien 2390075Sobrien#include "config.h" 2490075Sobrien#include <errno.h> 2590075Sobrien#include <sys/param.h> 2690075Sobrien#include "ctf-decls.h" 2790075Sobrien#include <ctf-api.h> 2890075Sobrien#include "ctf-sha1.h" 2990075Sobrien#include <sys/types.h> 3090075Sobrien#include <stdlib.h> 3190075Sobrien#include <stdarg.h> 3252284Sobrien#include <stddef.h> 3352284Sobrien#include <stdio.h> 3490075Sobrien#include <stdint.h> 3590075Sobrien#include <string.h> 3690075Sobrien#include <limits.h> 3790075Sobrien#include <ctype.h> 3890075Sobrien#include <elf.h> 3990075Sobrien#include <bfd.h> 4090075Sobrien#include "hashtab.h" 4190075Sobrien#include "ctf-intl.h" 4290075Sobrien 4390075Sobrien#ifdef __cplusplus 4490075Sobrienextern "C" 4590075Sobrien{ 4690075Sobrien#endif 4790075Sobrien 4890075Sobrien/* Tuning. */ 4990075Sobrien 5090075Sobrien/* The proportion of symtypetab entries which must be pads before we consider it 5190075Sobrien worthwhile to emit a symtypetab section as an index. Indexes cost time to 5290075Sobrien look up, but save space all told. Do not set to 1, since this will cause 5390075Sobrien indexes to be eschewed completely, even in child dicts, at considerable space 5490075Sobrien cost. */ 5590075Sobrien#define CTF_INDEX_PAD_THRESHOLD .75 5690075Sobrien 5752284Sobrien/* Compiler attributes. */ 5852284Sobrien 5952284Sobrien#if defined (__GNUC__) 6052284Sobrien 6152284Sobrien/* GCC. We assume that all compilers claiming to be GCC support sufficiently 6252284Sobrien many GCC attributes that the code below works. If some non-GCC compilers 6352284Sobrien masquerading as GCC in fact do not implement these attributes, version checks 6452284Sobrien may be required. */ 6552284Sobrien 6652284Sobrien/* We use the _libctf_*_ pattern to avoid clashes with any future attribute 6752284Sobrien macros glibc may introduce, which have names of the pattern 6852284Sobrien __attribute_blah__. */ 6952284Sobrien 7052284Sobrien#define _libctf_printflike_(string_index,first_to_check) \ 7152284Sobrien __attribute__ ((__format__ (__printf__, (string_index), (first_to_check)))) 7252284Sobrien#define _libctf_unlikely_(x) __builtin_expect ((x), 0) 7352284Sobrien#define _libctf_unused_ __attribute__ ((__unused__)) 7452284Sobrien#define _libctf_malloc_ __attribute__((__malloc__)) 7552284Sobrien#define _libctf_nonnull_(params) __attribute__((__nonnull__ params)) 7652284Sobrien 7752284Sobrien#else 7852284Sobrien 7952284Sobrien#define _libctf_printflike_(string_index,first_to_check) 8052284Sobrien#define _libctf_unlikely_(x) (x) 8152284Sobrien#define _libctf_unused_ 8252284Sobrien#define _libctf_malloc_ 8352284Sobrien#define _libctf_nonnull_(params) 8452284Sobrien#define __extension__ 8552284Sobrien 8652284Sobrien#endif 8752284Sobrien 8852284Sobrien#if defined (ENABLE_LIBCTF_HASH_DEBUGGING) && !defined (NDEBUG) 8952284Sobrien#include <assert.h> 9052284Sobrien#define ctf_assert(fp, expr) (assert (expr), 1) 9152284Sobrien#else 9252284Sobrien#define ctf_assert(fp, expr) \ 9352284Sobrien _libctf_unlikely_ (ctf_assert_internal (fp, __FILE__, __LINE__, \ 9452284Sobrien #expr, !!(expr))) 9552284Sobrien#endif 9652284Sobrien 9752284Sobrien/* libctf in-memory state. */ 9852284Sobrien 9952284Sobrientypedef struct ctf_fixed_hash ctf_hash_t; /* Private to ctf-hash.c. */ 10052284Sobrientypedef struct ctf_dynhash ctf_dynhash_t; /* Private to ctf-hash.c. */ 10152284Sobrientypedef struct ctf_dynset ctf_dynset_t; /* Private to ctf-hash.c. */ 10252284Sobrien 10352284Sobrientypedef struct ctf_strs 10452284Sobrien{ 10552284Sobrien const char *cts_strs; /* Base address of string table. */ 10652284Sobrien size_t cts_len; /* Size of string table in bytes. */ 10752284Sobrien} ctf_strs_t; 10852284Sobrien 10952284Sobrientypedef struct ctf_strs_writable 11052284Sobrien{ 11152284Sobrien char *cts_strs; /* Base address of string table. */ 11252284Sobrien size_t cts_len; /* Size of string table in bytes. */ 11352284Sobrien} ctf_strs_writable_t; 11452284Sobrien 11552284Sobrientypedef struct ctf_dmodel 11652284Sobrien{ 11752284Sobrien const char *ctd_name; /* Data model name. */ 11852284Sobrien int ctd_code; /* Data model code. */ 11952284Sobrien size_t ctd_pointer; /* Size of void * in bytes. */ 12052284Sobrien size_t ctd_char; /* Size of char in bytes. */ 12152284Sobrien size_t ctd_short; /* Size of short in bytes. */ 12252284Sobrien size_t ctd_int; /* Size of int in bytes. */ 12352284Sobrien size_t ctd_long; /* Size of long in bytes. */ 12452284Sobrien} ctf_dmodel_t; 12552284Sobrien 12652284Sobrientypedef struct ctf_names 12752284Sobrien{ 12852284Sobrien ctf_hash_t *ctn_readonly; /* Hash table when readonly. */ 12952284Sobrien ctf_dynhash_t *ctn_writable; /* Hash table when writable. */ 13052284Sobrien} ctf_names_t; 13152284Sobrien 13290075Sobrientypedef struct ctf_lookup 13390075Sobrien{ 13490075Sobrien const char *ctl_prefix; /* String prefix for this lookup. */ 13552284Sobrien size_t ctl_len; /* Length of prefix string in bytes. */ 13690075Sobrien ctf_names_t *ctl_hash; /* Pointer to hash table for lookup. */ 13790075Sobrien} ctf_lookup_t; 13890075Sobrien 13990075Sobrientypedef struct ctf_dictops 14090075Sobrien{ 14190075Sobrien uint32_t (*ctfo_get_kind) (uint32_t); 14290075Sobrien uint32_t (*ctfo_get_root) (uint32_t); 14390075Sobrien uint32_t (*ctfo_get_vlen) (uint32_t); 14490075Sobrien ssize_t (*ctfo_get_ctt_size) (const ctf_dict_t *, const ctf_type_t *, 14590075Sobrien ssize_t *, ssize_t *); 14690075Sobrien ssize_t (*ctfo_get_vbytes) (ctf_dict_t *, unsigned short, ssize_t, size_t); 14790075Sobrien} ctf_dictops_t; 14890075Sobrien 14990075Sobrientypedef struct ctf_list 15090075Sobrien{ 15190075Sobrien struct ctf_list *l_prev; /* Previous pointer or tail pointer. */ 15290075Sobrien struct ctf_list *l_next; /* Next pointer or head pointer. */ 15390075Sobrien} ctf_list_t; 154 155typedef enum 156 { 157 CTF_PREC_BASE, 158 CTF_PREC_POINTER, 159 CTF_PREC_ARRAY, 160 CTF_PREC_FUNCTION, 161 CTF_PREC_MAX 162 } ctf_decl_prec_t; 163 164typedef struct ctf_decl_node 165{ 166 ctf_list_t cd_list; /* Linked list pointers. */ 167 ctf_id_t cd_type; /* Type identifier. */ 168 uint32_t cd_kind; /* Type kind. */ 169 uint32_t cd_n; /* Type dimension if array. */ 170} ctf_decl_node_t; 171 172typedef struct ctf_decl 173{ 174 ctf_list_t cd_nodes[CTF_PREC_MAX]; /* Declaration node stacks. */ 175 int cd_order[CTF_PREC_MAX]; /* Storage order of decls. */ 176 ctf_decl_prec_t cd_qualp; /* Qualifier precision. */ 177 ctf_decl_prec_t cd_ordp; /* Ordered precision. */ 178 char *cd_buf; /* Buffer for output. */ 179 int cd_err; /* Saved error value. */ 180 int cd_enomem; /* Nonzero if OOM during printing. */ 181} ctf_decl_t; 182 183typedef struct ctf_dtdef 184{ 185 ctf_list_t dtd_list; /* List forward/back pointers. */ 186 ctf_id_t dtd_type; /* Type identifier for this definition. */ 187 ctf_type_t dtd_data; /* Type node, including name. */ 188 size_t dtd_vlen_alloc; /* Total vlen space allocated. */ 189 unsigned char *dtd_vlen; /* Variable-length data for this type. */ 190} ctf_dtdef_t; 191 192typedef struct ctf_dvdef 193{ 194 ctf_list_t dvd_list; /* List forward/back pointers. */ 195 char *dvd_name; /* Name associated with variable. */ 196 ctf_id_t dvd_type; /* Type of variable. */ 197 unsigned long dvd_snapshots; /* Snapshot count when inserted. */ 198} ctf_dvdef_t; 199 200typedef struct ctf_err_warning 201{ 202 ctf_list_t cew_list; /* List forward/back pointers. */ 203 int cew_is_warning; /* 1 if warning, 0 if error. */ 204 char *cew_text; /* Error/warning text. */ 205} ctf_err_warning_t; 206 207/* Atoms associate strings with a list of the CTF items that reference that 208 string, so that ctf_update() can instantiate all the strings using the 209 ctf_str_atoms and then reassociate them with the real string later. 210 211 Strings can be interned into ctf_str_atom without having refs associated 212 with them, for values that are returned to callers, etc. Items are only 213 removed from this table on ctf_close(), but on every ctf_update(), all the 214 csa_refs in all entries are purged. */ 215 216typedef struct ctf_str_atom 217{ 218 const char *csa_str; /* Backpointer to string (hash key). */ 219 ctf_list_t csa_refs; /* This string's refs. */ 220 uint32_t csa_offset; /* Strtab offset, if any. */ 221 uint32_t csa_external_offset; /* External strtab offset, if any. */ 222 unsigned long csa_snapshot_id; /* Snapshot ID at time of creation. */ 223} ctf_str_atom_t; 224 225/* The refs of a single string in the atoms table. */ 226 227typedef struct ctf_str_atom_ref 228{ 229 ctf_list_t caf_list; /* List forward/back pointers. */ 230 uint32_t *caf_ref; /* A single ref to this string. */ 231} ctf_str_atom_ref_t; 232 233/* A single linker-provided symbol, during symbol addition, possibly before we 234 have been given external strtab refs. */ 235typedef struct ctf_in_flight_dynsym 236{ 237 ctf_list_t cid_list; /* List forward/back pointers. */ 238 ctf_link_sym_t cid_sym; /* The linker-known symbol. */ 239} ctf_in_flight_dynsym_t; 240 241/* The structure used as the key in a ctf_link_type_mapping. The value is a 242 type index, not a type ID. */ 243 244typedef struct ctf_link_type_key 245{ 246 ctf_dict_t *cltk_fp; 247 ctf_id_t cltk_idx; 248} ctf_link_type_key_t; 249 250/* The structure used as the key in a cd_id_to_dict_t on 32-bit platforms. */ 251typedef struct ctf_type_id_key 252{ 253 int ctii_input_num; 254 ctf_id_t ctii_type; 255} ctf_type_id_key_t; 256 257/* Deduplicator state. 258 259 The dedup state below uses three terms consistently. A "hash" is a 260 ctf_dynhash_t; a "hash value" is the hash value of a type as returned by 261 ctf_dedup_hash_type; a "global type ID" or "global ID" is a packed-together 262 reference to a single ctf_dict_t (by array index in an array of inputs) and 263 ctf_id_t, i.e. a single instance of some hash value in some input. 264 265 The deduplication algorithm takes a bunch of inputs and yields a single 266 shared "output" and possibly many outputs corresponding to individual inputs 267 that still contain types after sharing of unconflicted types. Almost all 268 deduplicator state is stored in the struct ctf_dedup in the output, though a 269 (very) few things are stored in inputs for simplicity's sake, usually if they 270 are linking together things within the scope of a single TU. 271 272 Flushed at the end of every ctf_dedup run. */ 273 274typedef struct ctf_dedup 275{ 276 /* The CTF linker flags in force for this dedup run. */ 277 int cd_link_flags; 278 279 /* On 32-bit platforms only, a hash of global type IDs, in the form of 280 a ctf_link_type_id_key_t. */ 281 ctf_dynhash_t *cd_id_to_dict_t; 282 283 /* Atoms tables of decorated names: maps undecorated name to decorated name. 284 (The actual allocations are in the CTF dict for the former and the real 285 atoms table for the latter). Uses the same namespaces as ctf_lookups, 286 below, but has no need for null-termination. */ 287 ctf_dynhash_t *cd_decorated_names[4]; 288 289 /* Map type names to a hash from type hash value -> number of times each value 290 has appeared. */ 291 ctf_dynhash_t *cd_name_counts; 292 293 /* Map global type IDs to type hash values. Used to determine if types are 294 already hashed without having to recompute their hash values again, and to 295 link types together at later stages. Forwards that are peeked through to 296 structs and unions are not represented in here, so lookups that might be 297 such a type (in practice, all lookups) must go via cd_replaced_types first 298 to take this into account. Discarded before each rehashing. */ 299 ctf_dynhash_t *cd_type_hashes; 300 301 /* Maps from the names of structs/unions/enums to a a single GID which is the 302 only appearance of that type in any input: if it appears in more than one 303 input, a value which is a GID with an input_num of -1 appears. Used in 304 share-duplicated link mode link modes to determine whether structs/unions 305 can be cited from multiple TUs. Only populated in that link mode. */ 306 ctf_dynhash_t *cd_struct_origin; 307 308 /* Maps type hash values to a set of hash values of the types that cite them: 309 i.e., pointing backwards up the type graph. Used for recursive conflict 310 marking. Citations from tagged structures, unions, and forwards do not 311 appear in this graph. */ 312 ctf_dynhash_t *cd_citers; 313 314 /* Maps type hash values to input global type IDs. The value is a set (a 315 hash) of global type IDs. Discarded before each rehashing. The result of 316 the ctf_dedup function. */ 317 ctf_dynhash_t *cd_output_mapping; 318 319 /* A map giving the GID of the first appearance of each type for each type 320 hash value. */ 321 ctf_dynhash_t *cd_output_first_gid; 322 323 /* Used to ensure that we never try to map a single type ID to more than one 324 hash. */ 325 ctf_dynhash_t *cd_output_mapping_guard; 326 327 /* Maps the global type IDs of structures in input TUs whose members still 328 need emission to the global type ID of the already-emitted target type 329 (which has no members yet) in the appropriate target. Uniquely, the latter 330 ID represents a *target* ID (i.e. the cd_output_mapping of some specified 331 input): we encode the shared (parent) dict with an ID of -1. */ 332 ctf_dynhash_t *cd_emission_struct_members; 333 334 /* A set (a hash) of hash values of conflicting types. */ 335 ctf_dynset_t *cd_conflicting_types; 336 337 /* A hash mapping fp *'s of inputs to their input_nums. Used only by 338 functions outside the core ctf_dedup / ctf_dedup_emit machinery which do 339 not take an inputs array. */ 340 ctf_dynhash_t *cd_input_nums; 341 342 /* Maps type hashes to ctf_id_t's in this dictionary. Populated only at 343 emission time, in the dictionary where emission is taking place. */ 344 ctf_dynhash_t *cd_output_emission_hashes; 345 346 /* Maps the decorated names of conflicted cross-TU forwards that were forcibly 347 emitted in this TU to their emitted ctf_id_ts. Populated only at emission 348 time, in the dictionary where emission is taking place. */ 349 ctf_dynhash_t *cd_output_emission_conflicted_forwards; 350 351 /* Points to the output counterpart of this input dictionary, at emission 352 time. */ 353 ctf_dict_t *cd_output; 354} ctf_dedup_t; 355 356/* The ctf_dict is the structure used to represent a CTF dictionary to library 357 clients, who see it only as an opaque pointer. Modifications can therefore 358 be made freely to this structure without regard to client versioning. The 359 ctf_dict_t typedef appears in <ctf-api.h> and declares a forward tag. 360 (A ctf_file_t typedef also appears there, for historical reasons.) 361 362 NOTE: ctf_serialize requires that everything inside of ctf_dict either be an 363 immediate value, a pointer to dynamically allocated data *outside* of the 364 ctf_dict itself, a pointer to statically allocated data, or specially handled 365 in ctf_serialize. If you add a pointer to ctf_dict that points to something 366 within the ctf_dict itself, you must make corresponding changes to 367 ctf_serialize. */ 368 369struct 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_symtab; /* Symbol table from object file. */ 376 ctf_sect_t ctf_strtab; /* String table from object file. */ 377 int ctf_symsect_little_endian; /* Endianness of the ctf_symtab. */ 378 ctf_dynhash_t *ctf_symhash; /* (partial) hash, symsect name -> idx. */ 379 size_t ctf_symhash_latest; /* Amount of symsect scanned so far. */ 380 ctf_dynhash_t *ctf_prov_strtab; /* Maps provisional-strtab offsets 381 to names. */ 382 ctf_dynhash_t *ctf_syn_ext_strtab; /* Maps ext-strtab offsets to names. */ 383 void *ctf_data_mmapped; /* CTF data we mmapped, to free later. */ 384 size_t ctf_data_mmapped_len; /* Length of CTF data we mmapped. */ 385 ctf_names_t ctf_structs; /* Hash table of struct types. */ 386 ctf_names_t ctf_unions; /* Hash table of union types. */ 387 ctf_names_t ctf_enums; /* Hash table of enum types. */ 388 ctf_names_t ctf_names; /* Hash table of remaining type names. */ 389 ctf_lookup_t ctf_lookups[5]; /* Pointers to nametabs for name lookup. */ 390 ctf_strs_t ctf_str[2]; /* Array of string table base and bounds. */ 391 ctf_dynhash_t *ctf_str_atoms; /* Hash table of ctf_str_atoms_t. */ 392 ctf_dynset_t *ctf_str_pending_ref; /* Locations awaiting ref addition. */ 393 uint64_t ctf_str_num_refs; /* Number of refs to cts_str_atoms. */ 394 uint32_t ctf_str_prov_offset; /* Latest provisional offset assigned so far. */ 395 unsigned char *ctf_base; /* CTF file pointer. */ 396 unsigned char *ctf_dynbase; /* Freeable CTF file pointer. */ 397 unsigned char *ctf_buf; /* Uncompressed CTF data buffer. */ 398 size_t ctf_size; /* Size of CTF header + uncompressed data. */ 399 uint32_t *ctf_sxlate; /* Translation table for unindexed symtypetab 400 entries. */ 401 unsigned long ctf_nsyms; /* Number of entries in symtab xlate table. */ 402 uint32_t *ctf_txlate; /* Translation table for type IDs. */ 403 uint32_t *ctf_ptrtab; /* Translation table for pointer-to lookups. */ 404 size_t ctf_ptrtab_len; /* Num types storable in ptrtab currently. */ 405 uint32_t *ctf_pptrtab; /* Parent types pointed to by child dicts. */ 406 size_t ctf_pptrtab_len; /* Num types storable in pptrtab currently. */ 407 uint32_t ctf_pptrtab_typemax; /* Max child type when pptrtab last updated. */ 408 uint32_t *ctf_funcidx_names; /* Name of each function symbol in symtypetab 409 (if indexed). */ 410 uint32_t *ctf_objtidx_names; /* Likewise, for object symbols. */ 411 size_t ctf_nfuncidx; /* Number of funcidx entries. */ 412 uint32_t *ctf_funcidx_sxlate; /* Offsets into funcinfo for a given funcidx. */ 413 uint32_t *ctf_objtidx_sxlate; /* Likewise, for ctf_objtidx. */ 414 size_t ctf_nobjtidx; /* Number of objtidx entries. */ 415 ctf_dynhash_t *ctf_objthash; /* name -> type ID. */ 416 ctf_dynhash_t *ctf_funchash; /* name -> CTF_K_FUNCTION type ID. */ 417 418 /* The next three are linker-derived state found in ctf_link targets only. */ 419 420 ctf_dynhash_t *ctf_dynsyms; /* Symbol info from ctf_link_shuffle_syms. */ 421 ctf_link_sym_t **ctf_dynsymidx; /* Indexes ctf_dynsyms by symidx. */ 422 uint32_t ctf_dynsymmax; /* Maximum ctf_dynsym index. */ 423 ctf_list_t ctf_in_flight_dynsyms; /* Dynsyms during accumulation. */ 424 struct ctf_varent *ctf_vars; /* Sorted variable->type mapping. */ 425 unsigned long ctf_nvars; /* Number of variables in ctf_vars. */ 426 unsigned long ctf_typemax; /* Maximum valid type ID number. */ 427 const ctf_dmodel_t *ctf_dmodel; /* Data model pointer (see above). */ 428 const char *ctf_cuname; /* Compilation unit name (if any). */ 429 char *ctf_dyncuname; /* Dynamically allocated name of CU. */ 430 struct ctf_dict *ctf_parent; /* Parent CTF dict (if any). */ 431 int ctf_parent_unreffed; /* Parent set by ctf_import_unref? */ 432 const char *ctf_parlabel; /* Label in parent dict (if any). */ 433 const char *ctf_parname; /* Basename of parent (if any). */ 434 char *ctf_dynparname; /* Dynamically allocated name of parent. */ 435 uint32_t ctf_parmax; /* Highest type ID of a parent type. */ 436 uint32_t ctf_refcnt; /* Reference count (for parent links). */ 437 uint32_t ctf_flags; /* Libctf flags (see below). */ 438 int ctf_errno; /* Error code for most recent error. */ 439 int ctf_version; /* CTF data version. */ 440 ctf_dynhash_t *ctf_dthash; /* Hash of dynamic type definitions. */ 441 ctf_list_t ctf_dtdefs; /* List of dynamic type definitions. */ 442 ctf_dynhash_t *ctf_dvhash; /* Hash of dynamic variable mappings. */ 443 ctf_list_t ctf_dvdefs; /* List of dynamic variable definitions. */ 444 unsigned long ctf_dtoldid; /* Oldest id that has been committed. */ 445 unsigned long ctf_snapshots; /* ctf_snapshot() plus ctf_update() count. */ 446 unsigned long ctf_snapshot_lu; /* ctf_snapshot() call count at last update. */ 447 ctf_archive_t *ctf_archive; /* Archive this ctf_dict_t came from. */ 448 ctf_list_t ctf_errs_warnings; /* CTF errors and warnings. */ 449 ctf_dynhash_t *ctf_link_inputs; /* Inputs to this link. */ 450 ctf_dynhash_t *ctf_link_outputs; /* Additional outputs from this link. */ 451 452 /* If a link input CU, points at the corresponding per-CU output (if any); 453 if an output, points at the input (if any). */ 454 ctf_dict_t *ctf_link_in_out; 455 456 /* Map input types to output types for ctf_add_type. Key is a 457 ctf_link_type_key_t: value is a type ID. */ 458 ctf_dynhash_t *ctf_link_type_mapping; 459 460 /* Map input CU names to output CTF dict names: populated in the top-level 461 output dict. 462 463 Key and value are dynamically-allocated strings. */ 464 ctf_dynhash_t *ctf_link_in_cu_mapping; 465 466 /* Map output CTF dict names to input CU names: populated in the top-level 467 output dict. A hash of string to hash (set) of strings. Key and 468 individual value members are shared with ctf_link_in_cu_mapping. */ 469 ctf_dynhash_t *ctf_link_out_cu_mapping; 470 471 /* CTF linker flags. Set on the parent output dict (the one passed to 472 ctf_link). Only respected when LCTF_LINKING set in ctf_flags. */ 473 int ctf_link_flags; 474 475 /* Allow the caller to change the name of link archive members. */ 476 ctf_link_memb_name_changer_f *ctf_link_memb_name_changer; 477 void *ctf_link_memb_name_changer_arg; /* Argument for it. */ 478 479 /* Allow the caller to filter out variables they don't care about. */ 480 ctf_link_variable_filter_f *ctf_link_variable_filter; 481 void *ctf_link_variable_filter_arg; /* Argument for it. */ 482 483 ctf_dynhash_t *ctf_add_processing; /* Types ctf_add_type is working on now. */ 484 485 /* Atoms table for dedup string storage. All strings in the ctf_dedup_t are 486 stored here. Only the _alloc copy is allocated or freed: the 487 ctf_dedup_atoms may be pointed to some other CTF dict, to share its atoms. 488 We keep the atoms table outside the ctf_dedup so that atoms can be 489 preserved across multiple similar links, such as when doing cu-mapped 490 links. */ 491 ctf_dynset_t *ctf_dedup_atoms; 492 ctf_dynset_t *ctf_dedup_atoms_alloc; 493 494 ctf_dedup_t ctf_dedup; /* Deduplicator state. */ 495 496 char *ctf_tmp_typeslice; /* Storage for slicing up type names. */ 497 size_t ctf_tmp_typeslicelen; /* Size of the typeslice. */ 498 void *ctf_specific; /* Data for ctf_get/setspecific(). */ 499}; 500 501/* An abstraction over both a ctf_dict_t and a ctf_archive_t. */ 502 503struct ctf_archive_internal 504{ 505 int ctfi_is_archive; 506 int ctfi_unmap_on_close; 507 ctf_dict_t *ctfi_dict; 508 struct ctf_archive *ctfi_archive; 509 ctf_dynhash_t *ctfi_dicts; /* Dicts we have opened and cached. */ 510 ctf_dict_t *ctfi_crossdict_cache; /* Cross-dict caching. */ 511 ctf_dict_t **ctfi_symdicts; /* Array of index -> ctf_dict_t *. */ 512 ctf_dynhash_t *ctfi_symnamedicts; /* Hash of name -> ctf_dict_t *. */ 513 ctf_sect_t ctfi_symsect; 514 int ctfi_symsect_little_endian; /* -1 for unknown / do not set. */ 515 ctf_sect_t ctfi_strsect; 516 int ctfi_free_symsect; 517 int ctfi_free_strsect; 518 void *ctfi_data; 519 bfd *ctfi_abfd; /* Optional source of section data. */ 520 void (*ctfi_bfd_close) (struct ctf_archive_internal *); 521}; 522 523/* Iterator state for the *_next() functions. */ 524 525/* A single hash key/value pair. */ 526typedef struct ctf_next_hkv 527{ 528 void *hkv_key; 529 void *hkv_value; 530} ctf_next_hkv_t; 531 532struct ctf_next 533{ 534 void (*ctn_iter_fun) (void); 535 ctf_id_t ctn_type; 536 ssize_t ctn_size; 537 ssize_t ctn_increment; 538 const ctf_type_t *ctn_tp; 539 uint32_t ctn_n; 540 541 /* Some iterators contain other iterators, in addition to their other 542 state. */ 543 ctf_next_t *ctn_next; 544 545 /* We can save space on this side of things by noting that a dictionary is 546 either dynamic or not, as a whole, and a given iterator can only iterate 547 over one kind of thing at once: so we can overlap the DTD and non-DTD 548 members, and the structure, variable and enum members, etc. */ 549 union 550 { 551 unsigned char *ctn_vlen; 552 const ctf_enum_t *ctn_en; 553 const ctf_dvdef_t *ctn_dvd; 554 ctf_next_hkv_t *ctn_sorted_hkv; 555 void **ctn_hash_slot; 556 } u; 557 558 /* This union is of various sorts of dict we can iterate over: 559 currently dictionaries and archives, dynhashes, and dynsets. */ 560 union 561 { 562 const ctf_dict_t *ctn_fp; 563 const ctf_archive_t *ctn_arc; 564 const ctf_dynhash_t *ctn_h; 565 const ctf_dynset_t *ctn_s; 566 } cu; 567}; 568 569/* Return x rounded up to an alignment boundary. 570 eg, P2ROUNDUP(0x1234, 0x100) == 0x1300 (0x13*align) 571 eg, P2ROUNDUP(0x5600, 0x100) == 0x5600 (0x56*align) */ 572#define P2ROUNDUP(x, align) (-(-(x) & -(align))) 573 574/* * If an offs is not aligned already then round it up and align it. */ 575#define LCTF_ALIGN_OFFS(offs, align) ((offs + (align - 1)) & ~(align - 1)) 576 577#define LCTF_TYPE_ISPARENT(fp, id) ((id) <= fp->ctf_parmax) 578#define LCTF_TYPE_ISCHILD(fp, id) ((id) > fp->ctf_parmax) 579#define LCTF_TYPE_TO_INDEX(fp, id) ((id) & (fp->ctf_parmax)) 580#define LCTF_INDEX_TO_TYPE(fp, id, child) (child ? ((id) | (fp->ctf_parmax+1)) : \ 581 (id)) 582 583#define LCTF_INDEX_TO_TYPEPTR(fp, i) \ 584 ((fp->ctf_flags & LCTF_RDWR) ? \ 585 &(ctf_dtd_lookup (fp, LCTF_INDEX_TO_TYPE \ 586 (fp, i, fp->ctf_flags & LCTF_CHILD))->dtd_data) : \ 587 (ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)])) 588 589#define LCTF_INFO_KIND(fp, info) ((fp)->ctf_dictops->ctfo_get_kind(info)) 590#define LCTF_INFO_ISROOT(fp, info) ((fp)->ctf_dictops->ctfo_get_root(info)) 591#define LCTF_INFO_VLEN(fp, info) ((fp)->ctf_dictops->ctfo_get_vlen(info)) 592#define LCTF_VBYTES(fp, kind, size, vlen) \ 593 ((fp)->ctf_dictops->ctfo_get_vbytes(fp, kind, size, vlen)) 594 595#define LCTF_CHILD 0x0001 /* CTF dict is a child. */ 596#define LCTF_RDWR 0x0002 /* CTF dict is writable. */ 597#define LCTF_DIRTY 0x0004 /* CTF dict has been modified. */ 598#define LCTF_LINKING 0x0008 /* CTF link is underway: respect ctf_link_flags. */ 599 600extern ctf_names_t *ctf_name_table (ctf_dict_t *, int); 601extern const ctf_type_t *ctf_lookup_by_id (ctf_dict_t **, ctf_id_t); 602extern ctf_id_t ctf_lookup_by_rawname (ctf_dict_t *, int, const char *); 603extern ctf_id_t ctf_lookup_by_rawhash (ctf_dict_t *, ctf_names_t *, const char *); 604extern void ctf_set_ctl_hashes (ctf_dict_t *); 605 606extern int ctf_symtab_skippable (ctf_link_sym_t *sym); 607extern int ctf_add_funcobjt_sym (ctf_dict_t *, int is_function, 608 const char *, ctf_id_t); 609 610extern ctf_dict_t *ctf_get_dict (ctf_dict_t *fp, ctf_id_t type); 611 612typedef unsigned int (*ctf_hash_fun) (const void *ptr); 613extern unsigned int ctf_hash_integer (const void *ptr); 614extern unsigned int ctf_hash_string (const void *ptr); 615extern unsigned int ctf_hash_type_key (const void *ptr); 616extern unsigned int ctf_hash_type_id_key (const void *ptr); 617 618typedef int (*ctf_hash_eq_fun) (const void *, const void *); 619extern int ctf_hash_eq_integer (const void *, const void *); 620extern int ctf_hash_eq_string (const void *, const void *); 621extern int ctf_hash_eq_type_key (const void *, const void *); 622extern int ctf_hash_eq_type_id_key (const void *, const void *); 623 624typedef void (*ctf_hash_free_fun) (void *); 625 626typedef void (*ctf_hash_iter_f) (void *key, void *value, void *arg); 627typedef int (*ctf_hash_iter_remove_f) (void *key, void *value, void *arg); 628typedef int (*ctf_hash_iter_find_f) (void *key, void *value, void *arg); 629typedef int (*ctf_hash_sort_f) (const ctf_next_hkv_t *, const ctf_next_hkv_t *, 630 void *arg); 631 632extern ctf_hash_t *ctf_hash_create (unsigned long, ctf_hash_fun, ctf_hash_eq_fun); 633extern int ctf_hash_insert_type (ctf_hash_t *, ctf_dict_t *, uint32_t, uint32_t); 634extern int ctf_hash_define_type (ctf_hash_t *, ctf_dict_t *, uint32_t, uint32_t); 635extern ctf_id_t ctf_hash_lookup_type (ctf_hash_t *, ctf_dict_t *, const char *); 636extern uint32_t ctf_hash_size (const ctf_hash_t *); 637extern void ctf_hash_destroy (ctf_hash_t *); 638 639extern ctf_dynhash_t *ctf_dynhash_create (ctf_hash_fun, ctf_hash_eq_fun, 640 ctf_hash_free_fun, ctf_hash_free_fun); 641extern int ctf_dynhash_insert (ctf_dynhash_t *, void *, void *); 642extern void ctf_dynhash_remove (ctf_dynhash_t *, const void *); 643extern size_t ctf_dynhash_elements (ctf_dynhash_t *); 644extern void ctf_dynhash_empty (ctf_dynhash_t *); 645extern void *ctf_dynhash_lookup (ctf_dynhash_t *, const void *); 646extern int ctf_dynhash_lookup_kv (ctf_dynhash_t *, const void *key, 647 const void **orig_key, void **value); 648extern void ctf_dynhash_destroy (ctf_dynhash_t *); 649extern void ctf_dynhash_iter (ctf_dynhash_t *, ctf_hash_iter_f, void *); 650extern void ctf_dynhash_iter_remove (ctf_dynhash_t *, ctf_hash_iter_remove_f, 651 void *); 652extern void *ctf_dynhash_iter_find (ctf_dynhash_t *, ctf_hash_iter_find_f, 653 void *); 654extern int ctf_dynhash_sort_by_name (const ctf_next_hkv_t *, 655 const ctf_next_hkv_t *, 656 void * _libctf_unused_); 657extern int ctf_dynhash_next (ctf_dynhash_t *, ctf_next_t **, 658 void **key, void **value); 659extern int ctf_dynhash_next_sorted (ctf_dynhash_t *, ctf_next_t **, 660 void **key, void **value, ctf_hash_sort_f, 661 void *); 662 663extern ctf_dynset_t *ctf_dynset_create (htab_hash, htab_eq, ctf_hash_free_fun); 664extern int ctf_dynset_insert (ctf_dynset_t *, void *); 665extern void ctf_dynset_remove (ctf_dynset_t *, const void *); 666extern void ctf_dynset_destroy (ctf_dynset_t *); 667extern void *ctf_dynset_lookup (ctf_dynset_t *, const void *); 668extern size_t ctf_dynset_elements (ctf_dynset_t *); 669extern int ctf_dynset_exists (ctf_dynset_t *, const void *key, 670 const void **orig_key); 671extern int ctf_dynset_next (ctf_dynset_t *, ctf_next_t **, void **key); 672extern void *ctf_dynset_lookup_any (ctf_dynset_t *); 673 674extern void ctf_sha1_init (ctf_sha1_t *); 675extern void ctf_sha1_add (ctf_sha1_t *, const void *, size_t); 676extern char *ctf_sha1_fini (ctf_sha1_t *, char *); 677 678#define ctf_list_prev(elem) ((void *)(((ctf_list_t *)(elem))->l_prev)) 679#define ctf_list_next(elem) ((void *)(((ctf_list_t *)(elem))->l_next)) 680 681extern void ctf_list_append (ctf_list_t *, void *); 682extern void ctf_list_prepend (ctf_list_t *, void *); 683extern void ctf_list_delete (ctf_list_t *, void *); 684extern void ctf_list_splice (ctf_list_t *, ctf_list_t *); 685extern int ctf_list_empty_p (ctf_list_t *lp); 686 687extern int ctf_dtd_insert (ctf_dict_t *, ctf_dtdef_t *, int flag, int kind); 688extern void ctf_dtd_delete (ctf_dict_t *, ctf_dtdef_t *); 689extern ctf_dtdef_t *ctf_dtd_lookup (const ctf_dict_t *, ctf_id_t); 690extern ctf_dtdef_t *ctf_dynamic_type (const ctf_dict_t *, ctf_id_t); 691 692extern int ctf_dvd_insert (ctf_dict_t *, ctf_dvdef_t *); 693extern void ctf_dvd_delete (ctf_dict_t *, ctf_dvdef_t *); 694extern ctf_dvdef_t *ctf_dvd_lookup (const ctf_dict_t *, const char *); 695 696extern ctf_id_t ctf_add_encoded (ctf_dict_t *, uint32_t, const char *, 697 const ctf_encoding_t *, uint32_t kind); 698extern ctf_id_t ctf_add_reftype (ctf_dict_t *, uint32_t, ctf_id_t, 699 uint32_t kind); 700 701extern int ctf_dedup_atoms_init (ctf_dict_t *); 702extern int ctf_dedup (ctf_dict_t *, ctf_dict_t **, uint32_t ninputs, 703 uint32_t *parents, int cu_mapped); 704extern void ctf_dedup_fini (ctf_dict_t *, ctf_dict_t **, uint32_t); 705extern ctf_dict_t **ctf_dedup_emit (ctf_dict_t *, ctf_dict_t **, 706 uint32_t ninputs, uint32_t *parents, 707 uint32_t *noutputs, int cu_mapped); 708extern ctf_id_t ctf_dedup_type_mapping (ctf_dict_t *fp, ctf_dict_t *src_fp, 709 ctf_id_t src_type); 710 711extern void ctf_decl_init (ctf_decl_t *); 712extern void ctf_decl_fini (ctf_decl_t *); 713extern void ctf_decl_push (ctf_decl_t *, ctf_dict_t *, ctf_id_t); 714 715_libctf_printflike_ (2, 3) 716extern void ctf_decl_sprintf (ctf_decl_t *, const char *, ...); 717extern char *ctf_decl_buf (ctf_decl_t *cd); 718 719extern const char *ctf_strptr (ctf_dict_t *, uint32_t); 720extern const char *ctf_strraw (ctf_dict_t *, uint32_t); 721extern const char *ctf_strraw_explicit (ctf_dict_t *, uint32_t, 722 ctf_strs_t *); 723extern int ctf_str_create_atoms (ctf_dict_t *); 724extern void ctf_str_free_atoms (ctf_dict_t *); 725extern uint32_t ctf_str_add (ctf_dict_t *, const char *); 726extern uint32_t ctf_str_add_ref (ctf_dict_t *, const char *, uint32_t *ref); 727extern uint32_t ctf_str_add_pending (ctf_dict_t *, const char *, uint32_t *); 728extern int ctf_str_move_pending (ctf_dict_t *, uint32_t *, ptrdiff_t); 729extern int ctf_str_add_external (ctf_dict_t *, const char *, uint32_t offset); 730extern void ctf_str_remove_ref (ctf_dict_t *, const char *, uint32_t *ref); 731extern void ctf_str_rollback (ctf_dict_t *, ctf_snapshot_id_t); 732extern void ctf_str_purge_refs (ctf_dict_t *); 733extern ctf_strs_writable_t ctf_str_write_strtab (ctf_dict_t *); 734 735extern struct ctf_archive_internal * 736ctf_new_archive_internal (int is_archive, int unmap_on_close, 737 struct ctf_archive *, ctf_dict_t *, 738 const ctf_sect_t *symsect, 739 const ctf_sect_t *strsect, int *errp); 740extern struct ctf_archive *ctf_arc_open_internal (const char *, int *); 741extern void ctf_arc_close_internal (struct ctf_archive *); 742extern const ctf_preamble_t *ctf_arc_bufpreamble (const ctf_sect_t *); 743extern void *ctf_set_open_errno (int *, int); 744extern unsigned long ctf_set_errno (ctf_dict_t *, int); 745extern void ctf_flip_header (ctf_header_t *); 746extern int ctf_flip (ctf_dict_t *, ctf_header_t *, unsigned char *, int); 747 748extern ctf_dict_t *ctf_simple_open_internal (const char *, size_t, const char *, 749 size_t, size_t, 750 const char *, size_t, 751 ctf_dynhash_t *, int, int *); 752extern ctf_dict_t *ctf_bufopen_internal (const ctf_sect_t *, const ctf_sect_t *, 753 const ctf_sect_t *, ctf_dynhash_t *, 754 int, int *); 755extern int ctf_import_unref (ctf_dict_t *fp, ctf_dict_t *pfp); 756extern int ctf_serialize (ctf_dict_t *); 757 758_libctf_malloc_ 759extern void *ctf_mmap (size_t length, size_t offset, int fd); 760extern void ctf_munmap (void *, size_t); 761extern ssize_t ctf_pread (int fd, void *buf, ssize_t count, off_t offset); 762 763extern void *ctf_realloc (ctf_dict_t *, void *, size_t); 764extern char *ctf_str_append (char *, const char *); 765extern char *ctf_str_append_noerr (char *, const char *); 766 767extern ctf_id_t ctf_type_resolve_unsliced (ctf_dict_t *, ctf_id_t); 768extern int ctf_type_kind_unsliced (ctf_dict_t *, ctf_id_t); 769 770_libctf_printflike_ (1, 2) 771extern void ctf_dprintf (const char *, ...); 772extern void libctf_init_debug (void); 773 774_libctf_printflike_ (4, 5) 775extern void ctf_err_warn (ctf_dict_t *, int is_warning, int err, 776 const char *, ...); 777extern void ctf_err_warn_to_open (ctf_dict_t *); 778extern void ctf_assert_fail_internal (ctf_dict_t *, const char *, 779 size_t, const char *); 780extern const char *ctf_link_input_name (ctf_dict_t *); 781 782extern ctf_link_sym_t *ctf_elf32_to_link_sym (ctf_dict_t *fp, ctf_link_sym_t *dst, 783 const Elf32_Sym *src, uint32_t symidx); 784extern ctf_link_sym_t *ctf_elf64_to_link_sym (ctf_dict_t *fp, ctf_link_sym_t *dst, 785 const Elf64_Sym *src, uint32_t symidx); 786 787/* Variables, all underscore-prepended. */ 788 789extern const char _CTF_SECTION[]; /* name of CTF ELF section */ 790extern const char _CTF_NULLSTR[]; /* empty string */ 791 792extern int _libctf_version; /* library client version */ 793extern int _libctf_debug; /* debugging messages enabled */ 794 795#include "ctf-inlines.h" 796 797#ifdef __cplusplus 798} 799#endif 800 801#endif /* _CTF_IMPL_H */ 802