libctf/ctf-impl.h

   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
 212 typedef struct ctf_str_atom
 213 {
 214   char *csa_str;                /* Pointer to string (also used as hash key).  */
 215   ctf_list_t csa_refs;          /* This string's refs.  */
 216   ctf_list_t csa_movable_refs;  /* This string's movable refs.  */
 217   uint32_t csa_offset;          /* Offset in this strtab, 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.  Enumeration constants are tracked via the enum they appear
 298      in.  */
 299   ctf_dynhash_t *cd_name_counts;
 300
 301   /* Map global type IDs to type hash values.  Used to determine if types are
 302      already hashed without having to recompute their hash values again, and to
 303      link types together at later stages.  Forwards that are peeked through to
 304      structs and unions are not represented in here, so lookups that might be
 305      such a type (in practice, all lookups) must go via cd_replaced_types first
 306      to take this into account.  Discarded before each rehashing.  */
 307   ctf_dynhash_t *cd_type_hashes;
 308
 309   /* Maps from the names of structs/unions/enums to a a single GID which is the
 310      only appearance of that type in any input: if it appears in more than one
 311      input, a value which is a GID with an input_num of -1 appears.  Used in
 312      share-duplicated link mode link modes to determine whether structs/unions
 313      can be cited from multiple TUs.  Only populated in that link mode.  */
 314   ctf_dynhash_t *cd_struct_origin;
 315
 316   /* Maps type hash values to a set of hash values of the types that cite them:
 317      i.e., pointing backwards up the type graph.  Used for recursive conflict
 318      marking.  Citations from tagged structures, unions, and forwards do not
 319      appear in this graph.  */
 320   ctf_dynhash_t *cd_citers;
 321
 322   /* Maps type hash values to input global type IDs.  The value is a set (a
 323      hash) of global type IDs.  Discarded before each rehashing.  The result of
 324      the ctf_dedup function.  */
 325   ctf_dynhash_t *cd_output_mapping;
 326
 327   /* A map giving the GID of the first appearance of each type for each type
 328      hash value.  */
 329   ctf_dynhash_t *cd_output_first_gid;
 330
 331   /* Used to ensure that we never try to map a single type ID to more than one
 332      hash.  */
 333   ctf_dynhash_t *cd_output_mapping_guard;
 334
 335   /* Maps the global type IDs of structures in input TUs whose members still
 336      need emission to the global type ID of the already-emitted target type
 337      (which has no members yet) in the appropriate target.  Uniquely, the latter
 338      ID represents a *target* ID (i.e. the cd_output_mapping of some specified
 339      input): we encode the shared (parent) dict with an ID of -1.  */
 340   ctf_dynhash_t *cd_emission_struct_members;
 341
 342   /* A set (a hash) of hash values of conflicting types.  */
 343   ctf_dynset_t *cd_conflicting_types;
 344
 345   /* A hash mapping fp *'s of inputs to their input_nums.  Used only by
 346      functions outside the core ctf_dedup / ctf_dedup_emit machinery which do
 347      not take an inputs array.  */
 348   ctf_dynhash_t *cd_input_nums;
 349
 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;
 353
 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;
 358
 359   /* Points to the output counterpart of this input dictionary, at emission
 360      time.  */
 361   ctf_dict_t *cd_output;
 362 } ctf_dedup_t;
 363
 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.)  */
 369
 370 struct ctf_dict
 371 {
 372   const ctf_dictops_t *ctf_dictops; /* Version-specific dict operations.  */
 373   struct ctf_header *ctf_header;    /* The header from this CTF dict.  */
 374   unsigned char ctf_openflags;      /* Flags the dict had when opened.  */
 375   ctf_sect_t ctf_data;              /* CTF data from object file.  */
 376   ctf_sect_t ctf_ext_symtab;        /* Symbol table from object file.  */
 377   ctf_sect_t ctf_ext_strtab;        /* String table from object file.  */
 378   int ctf_symsect_little_endian;    /* Endianness of the ctf_ext_symtab.  */
 379   ctf_dynhash_t *ctf_symhash_func;  /* (partial) hash, symsect name -> idx. */
 380   ctf_dynhash_t *ctf_symhash_objt;  /* ditto, for object symbols.  */
 381   size_t ctf_symhash_latest;        /* Amount of symsect scanned so far.  */
 382   ctf_dynhash_t *ctf_prov_strtab;   /* Maps provisional-strtab offsets
 383                                        to names.  */
 384   ctf_dynhash_t *ctf_syn_ext_strtab; /* Maps ext-strtab offsets to names.  */
 385   void *ctf_data_mmapped;           /* CTF data we mmapped, to free later.  */
 386   size_t ctf_data_mmapped_len;      /* Length of CTF data we mmapped.  */
 387   ctf_dynhash_t *ctf_structs;       /* Hash table of struct types.  */
 388   ctf_dynhash_t *ctf_unions;        /* Hash table of union types.  */
 389   ctf_dynhash_t *ctf_enums;         /* Hash table of enum types.  */
 390   ctf_dynhash_t *ctf_names;         /* Hash table of remaining types, plus
 391                                        enumeration constants.  */
 392   ctf_lookup_t ctf_lookups[5];      /* Pointers to nametabs for name lookup.  */
 393   ctf_strs_t ctf_str[2];            /* Array of string table base and bounds.  */
 394   ctf_strs_writable_t *ctf_dynstrtab; /* Dynamically allocated string table, if any. */
 395   ctf_dynhash_t *ctf_str_atoms;   /* Hash table of ctf_str_atoms_t.  */
 396   ctf_dynhash_t *ctf_str_movable_refs; /* Hash table of void * -> ctf_str_atom_ref_movable_t.  */
 397   uint32_t ctf_str_prov_offset;   /* Latest provisional offset assigned so far.  */
 398   unsigned char *ctf_base;        /* CTF file pointer.  */
 399   unsigned char *ctf_dynbase;     /* Freeable CTF file pointer. */
 400   unsigned char *ctf_buf;         /* Uncompressed CTF data buffer.  */
 401   size_t ctf_size;                /* Size of CTF header + uncompressed data.  */
 402   uint32_t *ctf_sxlate;           /* Translation table for unindexed symtypetab
 403                                      entries.  */
 404   unsigned long ctf_nsyms;        /* Number of entries in symtab xlate table.  */
 405   uint32_t *ctf_txlate;           /* Translation table for type IDs.  */
 406   uint32_t *ctf_ptrtab;           /* Translation table for pointer-to lookups.  */
 407   size_t ctf_ptrtab_len;          /* Num types storable in ptrtab currently.  */
 408   uint32_t *ctf_pptrtab;          /* Parent types pointed to by child dicts.  */
 409   size_t ctf_pptrtab_len;         /* Num types storable in pptrtab currently.  */
 410   uint32_t ctf_pptrtab_typemax;   /* Max child type when pptrtab last updated.  */
 411   ctf_dynset_t *ctf_conflicting_enums;  /* Tracks enum constants that conflict.  */
 412   uint32_t *ctf_funcidx_names;    /* Name of each function symbol in symtypetab
 413                                      (if indexed).  */
 414   uint32_t *ctf_objtidx_names;    /* Likewise, for object symbols.  */
 415   size_t ctf_nfuncidx;            /* Number of funcidx entries.  */
 416   uint32_t *ctf_funcidx_sxlate;   /* Offsets into funcinfo for a given funcidx.  */
 417   uint32_t *ctf_objtidx_sxlate;   /* Likewise, for ctf_objtidx.  */
 418   size_t ctf_nobjtidx;            /* Number of objtidx entries.  */
 419   ctf_dynhash_t *ctf_objthash;    /* Dynamic: name -> type ID.  */
 420   ctf_dynhash_t *ctf_funchash;    /* Dynamic: name -> CTF_K_FUNCTION type ID.  */
 421
 422   /* The next three are linker-derived state found in ctf_link targets only.  */
 423
 424   ctf_dynhash_t *ctf_dynsyms;     /* Symbol info from ctf_link_shuffle_syms.  */
 425   ctf_link_sym_t **ctf_dynsymidx;  /* Indexes ctf_dynsyms by symidx.  */
 426   uint32_t ctf_dynsymmax;         /* Maximum ctf_dynsym index.  */
 427   ctf_list_t ctf_in_flight_dynsyms; /* Dynsyms during accumulation.  */
 428   struct ctf_varent *ctf_vars;    /* Sorted variable->type mapping.  */
 429   unsigned long ctf_nvars;        /* Number of variables in ctf_vars.  */
 430   unsigned long ctf_typemax;      /* Maximum valid type ID number.  */
 431   unsigned long ctf_stypes;       /* Number of static (non-dynamic) types.  */
 432   const ctf_dmodel_t *ctf_dmodel; /* Data model pointer (see above).  */
 433   const char *ctf_cuname;         /* Compilation unit name (if any).  */
 434   char *ctf_dyncuname;            /* Dynamically allocated name of CU.  */
 435   struct ctf_dict *ctf_parent;    /* Parent CTF dict (if any).  */
 436   int ctf_parent_unreffed;        /* Parent set by ctf_import_unref?  */
 437   const char *ctf_parlabel;       /* Label in parent dict (if any).  */
 438   const char *ctf_parname;        /* Basename of parent (if any).  */
 439   char *ctf_dynparname;           /* Dynamically allocated name of parent.  */
 440   uint32_t ctf_parmax;            /* Highest type ID of a parent type.  */
 441   uint32_t ctf_refcnt;            /* Reference count (for parent links).  */
 442   uint32_t ctf_flags;             /* Libctf flags (see below).  */
 443   int ctf_errno;                  /* Error code for most recent error.  */
 444   int ctf_version;                /* CTF data version.  */
 445   ctf_dynhash_t *ctf_dthash;      /* Hash of dynamic type definitions.  */
 446   ctf_list_t ctf_dtdefs;          /* List of dynamic type definitions.  */
 447   ctf_dynhash_t *ctf_dvhash;      /* Hash of dynamic variable mappings.  */
 448   ctf_list_t ctf_dvdefs;          /* List of dynamic variable definitions.  */
 449   unsigned long ctf_dtoldid;      /* Oldest id that has been committed.  */
 450   unsigned long ctf_snapshots;    /* ctf_snapshot() plus ctf_update() count.  */
 451   unsigned long ctf_snapshot_lu;  /* ctf_snapshot() call count at last update.  */
 452   ctf_archive_t *ctf_archive;     /* Archive this ctf_dict_t came from.  */
 453   ctf_list_t ctf_errs_warnings;   /* CTF errors and warnings.  */
 454   ctf_dynhash_t *ctf_link_inputs; /* Inputs to this link.  */
 455   ctf_dynhash_t *ctf_link_outputs; /* Additional outputs from this link.  */
 456
 457   /* If a link input CU, points at the corresponding per-CU output (if any);
 458      if an output, points at the input (if any).  */
 459   ctf_dict_t *ctf_link_in_out;
 460
 461   /* Map input types to output types for ctf_add_type.  Key is a
 462      ctf_link_type_key_t: value is a type ID.  */
 463   ctf_dynhash_t *ctf_link_type_mapping;
 464
 465   /* Map input CU names to output CTF dict names: populated in the top-level
 466      output dict.
 467
 468      Key and value are dynamically-allocated strings.  */
 469   ctf_dynhash_t *ctf_link_in_cu_mapping;
 470
 471   /* Map output CTF dict names to input CU names: populated in the top-level
 472      output dict.  A hash of string to hash (set) of strings.  Key and
 473      individual value members are shared with ctf_link_in_cu_mapping.  */
 474   ctf_dynhash_t *ctf_link_out_cu_mapping;
 475
 476   /* CTF linker flags.  Set on the parent output dict (the one passed to
 477      ctf_link).  Only respected when LCTF_LINKING set in ctf_flags.  */
 478   int ctf_link_flags;
 479
 480   /* Allow the caller to change the name of link archive members.  */
 481   ctf_link_memb_name_changer_f *ctf_link_memb_name_changer;
 482   void *ctf_link_memb_name_changer_arg;         /* Argument for it.  */
 483
 484   /* Allow the caller to filter out variables they don't care about.  */
 485   ctf_link_variable_filter_f *ctf_link_variable_filter;
 486   void *ctf_link_variable_filter_arg;           /* Argument for it. */
 487
 488   ctf_dynhash_t *ctf_add_processing; /* Types ctf_add_type is working on now.  */
 489
 490   /* Atoms table for dedup string storage.  All strings in the ctf_dedup_t are
 491      stored here.  Only the _alloc copy is allocated or freed: the
 492      ctf_dedup_atoms may be pointed to some other CTF dict, to share its atoms.
 493      We keep the atoms table outside the ctf_dedup so that atoms can be
 494      preserved across multiple similar links, such as when doing cu-mapped
 495      links.  */
 496   ctf_dynset_t *ctf_dedup_atoms;
 497   ctf_dynset_t *ctf_dedup_atoms_alloc;
 498
 499   ctf_dedup_t ctf_dedup;          /* Deduplicator state.  */
 500
 501   char *ctf_tmp_typeslice;        /* Storage for slicing up type names.  */
 502   size_t ctf_tmp_typeslicelen;    /* Size of the typeslice.  */
 503   void *ctf_specific;             /* Data for ctf_get/setspecific().  */
 504 };
 505
 506 /* An abstraction over both a ctf_dict_t and a ctf_archive_t.  */
 507
 508 struct ctf_archive_internal
 509 {
 510   int ctfi_is_archive;
 511   int ctfi_unmap_on_close;
 512   ctf_dict_t *ctfi_dict;
 513   struct ctf_archive *ctfi_archive;
 514   ctf_dynhash_t *ctfi_dicts;      /* Dicts we have opened and cached.  */
 515   ctf_dict_t *ctfi_crossdict_cache; /* Cross-dict caching.  */
 516   ctf_dict_t **ctfi_symdicts;     /* Array of index -> ctf_dict_t *.  */
 517   ctf_dynhash_t *ctfi_symnamedicts; /* Hash of name -> ctf_dict_t *.  */
 518   ctf_sect_t ctfi_symsect;
 519   int ctfi_symsect_little_endian; /* -1 for unknown / do not set.  */
 520   ctf_sect_t ctfi_strsect;
 521   int ctfi_free_symsect;
 522   int ctfi_free_strsect;
 523   void *ctfi_data;
 524   bfd *ctfi_abfd;                 /* Optional source of section data.  */
 525   void (*ctfi_bfd_close) (struct ctf_archive_internal *);
 526 };
 527
 528 /* Iterator state for the *_next() functions.  */
 529
 530 /* A single hash key/value pair.  */
 531 typedef struct ctf_next_hkv
 532 {
 533   void *hkv_key;
 534   void *hkv_value;
 535 } ctf_next_hkv_t;
 536
 537 struct ctf_next
 538 {
 539   void (*ctn_iter_fun) (void);
 540   ctf_id_t ctn_type;
 541   ssize_t ctn_size;
 542   ssize_t ctn_increment;
 543   const ctf_type_t *ctn_tp;
 544   uint32_t ctn_n;
 545
 546   /* Some iterators contain other iterators, in addition to their other
 547      state.  We allow for inner and outer iterators, for two-layer nested loops
 548      like those found in ctf_arc_lookup_enumerator_next.  */
 549   ctf_next_t *ctn_next;
 550   ctf_next_t *ctn_next_inner;
 551
 552   /* We can save space on this side of things by noting that a type is either
 553      dynamic or not, as a whole, and a given iterator can only iterate over one
 554      kind of thing at once: so we can overlap the DTD and non-DTD members, and
 555      the structure, variable and enum members, etc.  */
 556   union
 557   {
 558     unsigned char *ctn_vlen;
 559     const ctf_enum_t *ctn_en;
 560     const ctf_dvdef_t *ctn_dvd;
 561     ctf_next_hkv_t *ctn_sorted_hkv;
 562     void **ctn_hash_slot;
 563   } u;
 564
 565   /* This union is of various sorts of dict we can iterate over: currently
 566      archives, dictionaries, dynhashes, and dynsets.  ctn_fp is non-const
 567      because we need to set errors on it.  */
 568
 569   union
 570   {
 571     ctf_dict_t *ctn_fp;
 572     const ctf_archive_t *ctn_arc;
 573     const ctf_dynhash_t *ctn_h;
 574     const ctf_dynset_t *ctn_s;
 575   } cu;
 576 };
 577
 578 /* Return x rounded up to an alignment boundary.
 579    eg, P2ROUNDUP(0x1234, 0x100) == 0x1300 (0x13*align)
 580    eg, P2ROUNDUP(0x5600, 0x100) == 0x5600 (0x56*align)  */
 581 #define P2ROUNDUP(x, align)             (-(-(x) & -(align)))
 582
 583 /* * If an offs is not aligned already then round it up and align it. */
 584 #define LCTF_ALIGN_OFFS(offs, align) ((offs + (align - 1)) & ~(align - 1))
 585
 586 #define LCTF_TYPE_ISPARENT(fp, id) ((id) <= fp->ctf_parmax)
 587 #define LCTF_TYPE_ISCHILD(fp, id) ((id) > fp->ctf_parmax)
 588 #define LCTF_TYPE_TO_INDEX(fp, id) ((id) & (fp->ctf_parmax))
 589 #define LCTF_INDEX_TO_TYPE(fp, id, child) (child ? ((id) | (fp->ctf_parmax+1)) : \
 590                                            (id))
 591
 592 #define LCTF_INDEX_TO_TYPEPTR(fp, i) \
 593   ((i > fp->ctf_stypes) ?                                                       \
 594      &(ctf_dtd_lookup (fp, LCTF_INDEX_TO_TYPE                           \
 595                        (fp, i, fp->ctf_flags & LCTF_CHILD))->dtd_data) : \
 596      (ctf_type_t *)((uintptr_t)(fp)->ctf_buf + (fp)->ctf_txlate[(i)]))
 597
 598 #define LCTF_INFO_KIND(fp, info)        ((fp)->ctf_dictops->ctfo_get_kind(info))
 599 #define LCTF_INFO_ISROOT(fp, info)      ((fp)->ctf_dictops->ctfo_get_root(info))
 600 #define LCTF_INFO_VLEN(fp, info)        ((fp)->ctf_dictops->ctfo_get_vlen(info))
 601 #define LCTF_VBYTES(fp, kind, size, vlen) \
 602   ((fp)->ctf_dictops->ctfo_get_vbytes(fp, kind, size, vlen))
 603
 604 #define LCTF_CHILD      0x0001  /* CTF dict is a child.  */
 605 #define LCTF_LINKING    0x0002  /* CTF link is underway: respect ctf_link_flags.  */
 606 #define LCTF_STRICT_NO_DUP_ENUMERATORS 0x0004 /* Duplicate enums prohibited.  */
 607
 608 extern ctf_dynhash_t *ctf_name_table (ctf_dict_t *, int);
 609 extern const ctf_type_t *ctf_lookup_by_id (ctf_dict_t **, ctf_id_t);
 610 extern ctf_id_t ctf_lookup_variable_here (ctf_dict_t *fp, const char *name);
 611 extern ctf_id_t ctf_lookup_by_sym_or_name (ctf_dict_t *, unsigned long symidx,
 612                                            const char *symname, int try_parent,
 613                                            int is_function);
 614 extern ctf_id_t ctf_lookup_by_rawname (ctf_dict_t *, int, const char *);
 615 extern void ctf_set_ctl_hashes (ctf_dict_t *);
 616 extern ctf_id_t ctf_symbol_next_static (ctf_dict_t *, ctf_next_t **,
 617                                         const char **, int);
 618
 619 extern int ctf_symtab_skippable (ctf_link_sym_t *sym);
 620 extern int ctf_add_funcobjt_sym (ctf_dict_t *, int is_function,
 621                                  const char *, ctf_id_t);
 622
 623 extern ctf_dict_t *ctf_get_dict (ctf_dict_t *fp, ctf_id_t type);
 624
 625 typedef unsigned int (*ctf_hash_fun) (const void *ptr);
 626 extern unsigned int ctf_hash_integer (const void *ptr);
 627 extern unsigned int ctf_hash_string (const void *ptr);
 628 extern unsigned int ctf_hash_type_key (const void *ptr);
 629 extern unsigned int ctf_hash_type_id_key (const void *ptr);
 630
 631 typedef int (*ctf_hash_eq_fun) (const void *, const void *);
 632 extern int ctf_hash_eq_integer (const void *, const void *);
 633 extern int ctf_hash_eq_string (const void *, const void *);
 634 extern int ctf_hash_eq_type_key (const void *, const void *);
 635 extern int ctf_hash_eq_type_id_key (const void *, const void *);
 636
 637 typedef void (*ctf_hash_free_fun) (void *);
 638
 639 typedef void (*ctf_hash_iter_f) (void *key, void *value, void *arg);
 640 typedef int (*ctf_hash_iter_remove_f) (void *key, void *value, void *arg);
 641 typedef int (*ctf_hash_iter_find_f) (void *key, void *value, void *arg);
 642 typedef int (*ctf_hash_sort_f) (const ctf_next_hkv_t *, const ctf_next_hkv_t *,
 643                                 void *arg);
 644
 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 ctf_dynhash_t *ctf_dynhash_create_sized (unsigned long, ctf_hash_fun,
 648                                                 ctf_hash_eq_fun,
 649                                                 ctf_hash_free_fun,
 650                                                 ctf_hash_free_fun);
 651
 652 extern int ctf_dynhash_insert (ctf_dynhash_t *, void *, void *);
 653 extern void ctf_dynhash_remove (ctf_dynhash_t *, const void *);
 654 extern size_t ctf_dynhash_elements (ctf_dynhash_t *);
 655 extern void ctf_dynhash_empty (ctf_dynhash_t *);
 656 extern int ctf_dynhash_insert_type (ctf_dict_t *, ctf_dynhash_t *, uint32_t, uint32_t);
 657 extern ctf_id_t ctf_dynhash_lookup_type (ctf_dynhash_t *, const char *);
 658 extern void *ctf_dynhash_lookup (ctf_dynhash_t *, const void *);
 659 extern int ctf_dynhash_lookup_kv (ctf_dynhash_t *, const void *key,
 660                                   const void **orig_key, void **value);
 661 extern void ctf_dynhash_destroy (ctf_dynhash_t *);
 662 extern void ctf_dynhash_iter (ctf_dynhash_t *, ctf_hash_iter_f, void *);
 663 extern void ctf_dynhash_iter_remove (ctf_dynhash_t *, ctf_hash_iter_remove_f,
 664                                      void *);
 665 extern void *ctf_dynhash_iter_find (ctf_dynhash_t *, ctf_hash_iter_find_f,
 666                                     void *);
 667 extern int ctf_dynhash_sort_by_name (const ctf_next_hkv_t *,
 668                                      const ctf_next_hkv_t *,
 669                                      void * _libctf_unused_);
 670 extern int ctf_dynhash_next (ctf_dynhash_t *, ctf_next_t **,
 671                              void **key, void **value);
 672 extern int ctf_dynhash_next_sorted (ctf_dynhash_t *, ctf_next_t **,
 673                                     void **key, void **value, ctf_hash_sort_f,
 674                                     void *);
 675
 676 extern ctf_dynset_t *ctf_dynset_create (htab_hash, htab_eq, ctf_hash_free_fun);
 677 extern int ctf_dynset_insert (ctf_dynset_t *, void *);
 678 extern void ctf_dynset_remove (ctf_dynset_t *, const void *);
 679 extern size_t ctf_dynset_elements (ctf_dynset_t *);
 680 extern void ctf_dynset_destroy (ctf_dynset_t *);
 681 extern void *ctf_dynset_lookup (ctf_dynset_t *, const void *);
 682 extern int ctf_dynset_exists (ctf_dynset_t *, const void *key,
 683                               const void **orig_key);
 684 extern int ctf_dynset_next (ctf_dynset_t *, ctf_next_t **, void **key);
 685 extern void *ctf_dynset_lookup_any (ctf_dynset_t *);
 686
 687 extern void ctf_sha1_init (ctf_sha1_t *);
 688 extern void ctf_sha1_add (ctf_sha1_t *, const void *, size_t);
 689 extern char *ctf_sha1_fini (ctf_sha1_t *, char *);
 690
 691 #define ctf_list_prev(elem)     ((void *)(((ctf_list_t *)(elem))->l_prev))
 692 #define ctf_list_next(elem)     ((void *)(((ctf_list_t *)(elem))->l_next))
 693
 694 extern void ctf_list_append (ctf_list_t *, void *);
 695 extern void ctf_list_prepend (ctf_list_t *, void *);
 696 extern void ctf_list_delete (ctf_list_t *, void *);
 697 extern void ctf_list_splice (ctf_list_t *, ctf_list_t *);
 698 extern int ctf_list_empty_p (ctf_list_t *lp);
 699
 700 extern int ctf_dtd_insert (ctf_dict_t *, ctf_dtdef_t *, int flag, int kind);
 701 extern void ctf_dtd_delete (ctf_dict_t *, ctf_dtdef_t *);
 702 extern ctf_dtdef_t *ctf_dtd_lookup (const ctf_dict_t *, ctf_id_t);
 703 extern ctf_dtdef_t *ctf_dynamic_type (const ctf_dict_t *, ctf_id_t);
 704
 705 extern int ctf_dvd_insert (ctf_dict_t *, ctf_dvdef_t *);
 706 extern void ctf_dvd_delete (ctf_dict_t *, ctf_dvdef_t *);
 707 extern ctf_dvdef_t *ctf_dvd_lookup (const ctf_dict_t *, const char *);
 708
 709 extern ctf_id_t ctf_add_encoded (ctf_dict_t *, uint32_t, const char *,
 710                                  const ctf_encoding_t *, uint32_t kind);
 711 extern ctf_id_t ctf_add_reftype (ctf_dict_t *, uint32_t, ctf_id_t,
 712                                  uint32_t kind);
 713 extern int ctf_add_variable_forced (ctf_dict_t *, const char *, ctf_id_t);
 714 extern int ctf_add_funcobjt_sym_forced (ctf_dict_t *, int is_function,
 715                                         const char *, ctf_id_t);
 716
 717 extern int ctf_track_enumerator (ctf_dict_t *, ctf_id_t, const char *);
 718
 719 extern int ctf_dedup_atoms_init (ctf_dict_t *);
 720 extern int ctf_dedup (ctf_dict_t *, ctf_dict_t **, uint32_t ninputs,
 721                       int cu_mapped);
 722 extern ctf_dict_t **ctf_dedup_emit (ctf_dict_t *, ctf_dict_t **,
 723                                     uint32_t ninputs, uint32_t *parents,
 724                                     uint32_t *noutputs, int cu_mapped);
 725 extern void ctf_dedup_fini (ctf_dict_t *, ctf_dict_t **, uint32_t);
 726 extern ctf_id_t ctf_dedup_type_mapping (ctf_dict_t *fp, ctf_dict_t *src_fp,
 727                                         ctf_id_t src_type);
 728
 729 extern void ctf_decl_init (ctf_decl_t *);
 730 extern void ctf_decl_fini (ctf_decl_t *);
 731 extern void ctf_decl_push (ctf_decl_t *, ctf_dict_t *, ctf_id_t);
 732
 733 _libctf_printflike_ (2, 3)
 734 extern void ctf_decl_sprintf (ctf_decl_t *, const char *, ...);
 735 extern char *ctf_decl_buf (ctf_decl_t *cd);
 736
 737 extern const char *ctf_strptr (ctf_dict_t *, uint32_t);
 738 extern const char *ctf_strraw (ctf_dict_t *, uint32_t);
 739 extern const char *ctf_strraw_explicit (ctf_dict_t *, uint32_t,
 740                                         ctf_strs_t *);
 741 extern const char *ctf_strptr_validate (ctf_dict_t *, uint32_t);
 742 extern int ctf_str_create_atoms (ctf_dict_t *);
 743 extern void ctf_str_free_atoms (ctf_dict_t *);
 744 extern uint32_t ctf_str_add (ctf_dict_t *, const char *);
 745 extern uint32_t ctf_str_add_ref (ctf_dict_t *, const char *, uint32_t *ref);
 746 extern uint32_t ctf_str_add_movable_ref (ctf_dict_t *, const char *,
 747                                          uint32_t *ref);
 748 extern int ctf_str_move_refs (ctf_dict_t *fp, void *src, size_t len, void *dest);
 749 extern int ctf_str_add_external (ctf_dict_t *, const char *, uint32_t offset);
 750 extern void ctf_str_remove_ref (ctf_dict_t *, const char *, uint32_t *ref);
 751 extern void ctf_str_rollback (ctf_dict_t *, ctf_snapshot_id_t);
 752 extern const ctf_strs_writable_t *ctf_str_write_strtab (ctf_dict_t *);
 753
 754 extern struct ctf_archive_internal *
 755 ctf_new_archive_internal (int is_archive, int unmap_on_close,
 756                           struct ctf_archive *, ctf_dict_t *,
 757                           const ctf_sect_t *symsect,
 758                           const ctf_sect_t *strsect, int *errp);
 759 extern struct ctf_archive *ctf_arc_open_internal (const char *, int *);
 760 extern void ctf_arc_close_internal (struct ctf_archive *);
 761 extern const ctf_preamble_t *ctf_arc_bufpreamble (const ctf_sect_t *);
 762 extern void *ctf_set_open_errno (int *, int);
 763 extern void ctf_flip_header (ctf_header_t *);
 764 extern int ctf_flip (ctf_dict_t *, ctf_header_t *, unsigned char *, int);
 765
 766 extern int ctf_import_unref (ctf_dict_t *fp, ctf_dict_t *pfp);
 767
 768 extern int ctf_write_thresholded (ctf_dict_t *fp, int fd, size_t threshold);
 769
 770 _libctf_malloc_
 771 extern void *ctf_mmap (size_t length, size_t offset, int fd);
 772 extern void ctf_munmap (void *, size_t);
 773 extern ssize_t ctf_pread (int fd, void *buf, ssize_t count, off_t offset);
 774
 775 extern char *ctf_str_append (char *, const char *);
 776 extern char *ctf_str_append_noerr (char *, const char *);
 777
 778 extern ctf_id_t ctf_type_resolve_unsliced (ctf_dict_t *, ctf_id_t);
 779 extern int ctf_type_kind_unsliced (ctf_dict_t *, ctf_id_t);
 780
 781 _libctf_printflike_ (1, 2)
 782 extern void ctf_dprintf (const char *, ...);
 783 extern void libctf_init_debug (void);
 784
 785 _libctf_printflike_ (4, 5)
 786 extern void ctf_err_warn (ctf_dict_t *, int is_warning, int err,
 787                           const char *, ...);
 788 extern void ctf_err_warn_to_open (ctf_dict_t *);
 789 extern void ctf_assert_fail_internal (ctf_dict_t *, const char *,
 790                                       size_t, const char *);
 791 extern const char *ctf_link_input_name (ctf_dict_t *);
 792
 793 extern ctf_link_sym_t *ctf_elf32_to_link_sym (ctf_dict_t *fp, ctf_link_sym_t *dst,
 794                                               const Elf32_Sym *src, uint32_t symidx);
 795 extern ctf_link_sym_t *ctf_elf64_to_link_sym (ctf_dict_t *fp, ctf_link_sym_t *dst,
 796                                               const Elf64_Sym *src, uint32_t symidx);
 797
 798 /* Variables, all underscore-prepended. */
 799
 800 extern const char _CTF_SECTION[];       /* name of CTF ELF section */
 801 extern const char _CTF_NULLSTR[];       /* empty string */
 802
 803 extern int _libctf_version;     /* library client version */
 804 extern int _libctf_debug;       /* debugging messages enabled */
 805
 806 #include "ctf-inlines.h"
 807
 808 #ifdef  __cplusplus
 809 }
 810 #endif
 811
 812 #endif /* _CTF_IMPL_H */